Software Generation Method

ABSTRACT

To formalize, using process algebra, the process of automatic generation of software together with the semantics of Lyee generated software.  
     The present invention includes: a first step of declaring (defining) a user requirement to be mounted as one program as statements declared by word and grouped by logical record, each of which has a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word; a second step of preparing, from the statements by word, signification vectors (L 2 , L 3 , L 4 ) and action vectors (I 2 , O 4 , S 4 ), each of which is a modules of a process cell having input/output channels based on the Lyee-calculus; a third step of assembling the signification vectors and the action vectors into a set having the set condition that interactions among it is caused by a command from the same screen; a fourth step of placing one control function module Φ to each of the sets; and a fifth step of placing one control function module Ψ in the program.

TECHNICAL FIELD

The present invention relates to a software generating method, more particularly to a software generating method using formalization by process algebra in the Lyee methodology.

BACKGROUND ART

Over the last years, various methodologies and techniques have been elaborated and proposed to improve one or many aspects related to the software development life cycle. However, despite the great effort in this research field, the production of clearly understood and modifiable systems is still an ambitious goal and far from reached. This is due, on one hand, to the complexity and the subtlety of software themselves and, on the other hand, to the limitations of the current methodologies. Recently, a new and very promising methodology, called Lyee (trademark), has been proposed. Intended to deal efficiently with a wide range of software problems related to different field, Lyee allows the development of software by simply defining their requirements.

Nevertheless, since both the semantics of Lyee generated software together with the process of automatic generation of software from requirements are described using informal language, difficulties and confusions may arise when trying to understand and study this methodology.

Non-Patent Document 1

J. A. Bergstra and J. W. Klop. Algebra of communicating processes with abstraction. Theoretical Computer Science, 37(1):77-121, 1985.

Non-Patent Document 2

G. Berry and G. Boudol. The chemical abstract machine. Theoretical Computer Science, 96(1):217-248, 1992.

Non-Patent Document 3

C. A. R. Hoare. Communicating Sequential Processes. Prentice Hall International Series in Computer Science. Prentice Hall, 1985.

Non-Patent Document 4

M. Mejri, B. Ktari, and M. Erhioui. Static analysis on Lyee-oriented software. In Hamido Fujita and Paul Johannesson, editors, New Trends in Software Methodologies, Tools and Techniques, pages 375-394. IOS Press, 2002. Proceedings of 1st International Workshop on Lyee Methodology, Paris.

Non-Patent Document 5

R. Milner. A calculus of communicating systems. Lecture Notes in Computer Science 92, Berlin, 1980. Springer-Verlag.

Non-Patent Document 6

F. Negoro. Principle of Lyee software. 2000 International Conference on Information Society in 21st Century (IS2000), pages 121-189, November 2000.

Non-Patent Document 7

F. Negoro. Introduction to Lyee. The Institute of Computer Based Software Methodology and Technology, Tokyo, Japan, 2001.

Non-Patent Document 8

F. Negoro and I. Hamid. A proposal for intention engineering. 5th East-European Conference Advances in Databases and Information System (ADBIS' 2001), September 2000.

Non-Patent Document 9

F. Negoro and I. Hamid. A proposal for intention engineering. International Conference on Advances in Infrastructure for Electronic Business, Science, and Education on the Internet (SSGRR 2001), 2001.

DISCLOSURE OF THE INVENTION Problems to be Solved by the Invention

The main purpose of this invention is first to formalize, using process algebra, the process of automatic generation of software together with the semantics of Lyee generated software. Actually, the process algebra naturally supports many concepts of the Lyee methodology and consequently formalizes them simply and elegantly. Moreover, a second purpose is to offer the Lyee methodology an abstract machine more suitable than the Von-Newman one. In fact, this new abstract machine considers a program as a chemical solution when molecules (different vectors of the Lyee methodology) interact together to reach a collective goal.

Means for Solving the Problem

To solve such problem, the present invention comprises: a first step for making a statement (defining) a user requirement to be mounted as one program by a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; a second step for preparing, from the statement of the word unit, a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus; a third step for assembling the signification vector and the action vector into a set having set conditions that an interaction is caused by a command from an identical screen; a fourth step for disposing one control function module Φ for every set; and a fifth step for disposing a control function module Ψ being one for every program.

A program (software) for producing “software of a development object”, a program generation device, a program processing device, a tool (including both of tools as the device and the software), a software development device, a software development supporting device, or a software development and management device as one of different embodyments of the present invention may include: statement information inserting means for inserting information into an undefined portion of a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus, the information being obtained by forming the user requirement to be mounted as one program into information as a statement inclusing a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; control function Φ disposing means for associating the signification vector and the action vector with a set unit having set conditions that an interaction is caused by a command from from an identical screen so that one control function module Φ controls the set unit; and control function Ψ disposing means for associating one control function module Ψ with the control function Φ so as to control the control function Φ.

The present invention is also realized by the software produced by the above-described “method of producing software of the development object”, a recording medium on which the software is mounted, or a device (hardware) on which the software is mounted. In this case, the present invention may comprise: a module group obtained by inserting information into an undefined portion of a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus, the information being obtained by forming the user requirement to be mounted as one program into information as a statement inclusing a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; one or a plurality of control function modules Φ which associate the module group with a set unit having set conditions that an interaction is caused by a command from an identical screen so as to control the module group by one control function module Φ; and a control function module Ψ which associates a control function Φ so as to control the control function by one control function module Ψ.

Furthermore, the present invention is also realized as software which is a model of a software code for use in producing software by the above-described “method of producing the software of the development object”, as a recording medium on which the software is mounted, or as a device (hardware) on which the software is mounted. In this case, the present invention may be realized as a model which can be coded as software comprising: a model of a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus, the model having an undefined portion into which information is to be buried, the information being obtained by forming a user requirement to be mounted as one program into information as a statement including a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; a model of a control function module Φ having a function of controlling, with one control function module Φ, the signification vector and the action vector into whose undefined portion the information of the statement is inserted, for every a set unit having set conditions that an interaction is caused by a command from an identical screen; and a model of a control function module Ψ having a function of controlling the control function Φ by one control function module Ψ.

Furthermore, the present invention can be realized, by the above-described “method of producing the software of the development object”, as any of a method of extracting information (document (paper, data)) extracted from a requirement, as the information (document (paper, data)) extracted by such extraction method, as a method of using the extracted information, as an information recording medium on which these information is mounted, as a software in which an information extracting/using method is coded, and as a recording medium/device (hardware) on which the software is mounted. In these cases, the present invention may be realized as information extracted from a software development requirement, comprising: information obtained by forming a user requirement to be mounted as one program into information as a statement including a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit, the information being to be inserted into an undefined portion of a model of a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus; information for associating the signification vector and the action vector into whose undefined portion the information of the statement has been inserted with a set unit having set conditions that an interaction is caused by a command from an identical screen so as to control the vectors by one control function module Φ; and information which associates the control function Φ so as to control the function by one control function module Ψ.

It is to be noted that for the logical unit, Japanese Patent Application No. 2004-272400 by the same applicant is referred to, the contents of which are to be incorporated herein by reference.

Advantages of the Invention

A wide range of software problems related to different fields are efficiently dealt with, and development time, maintenance time, and documentation volume can be considerably reduced by using Lyee (as much as about 70 to 80%) as compared with conventional methodologies.

BEST MODES FOR CARRYING OUT THE INVENTION

Lyee Methodology: A Formalization using Process Algebra

Abstract: Over the last years, various methodologies and techniques have been elaborated and proposed to improve one or many aspects related to the software development life cycle. However, despite the great effort in this research field, the production of clearly understood and modifiable systems is still an ambitious goal and far from reached. This is due, on one hand, to the complexity and the subtlety of software themselves and, on the other hand, to the limitations of the current methodologies. Recently, a new and very promising methodology, called Lyee, has been proposed. Intended to deal efficiently with a wide range of software problems related to different field, Lyee allows the development of software by simply defining their requirements.

Nevertheless, since both the semantics of Lyee generated software together with the process of automatic generation of software from requirements are described using informal language, difficulties and confusions may arise when trying to understand and study this methodology.

The main purpose of this invention is first to formalize, using a process algebra, the process of automatic generation of software together with the semantics of Lyee generated software. Actually, the process algebra naturally supports many concepts of the Lyee methodology and consequently formalizes them simply and elegantly. Moreover, a second purpose is to offer the Lyee methodology an abstract machine more suitable than the Von-Newman one. In fact, this new abstract machine consider a program as chemical solution when molecules (different vectors of the lyee methodology) interact together to reach a collective goal.

1. Introduction

Producing easily and quickly software with high qualities is the basic concern of the software development research field. Over the last years, various methodologies and techniques have been elaborated and proposed to improve one or many aspects related to the software development life cycle. However, despite the great effort in this research field, the production of clearly understood and modifiable systems is still an ambitious goal and far from reached. This is due, on one hand, to the complexity and the subtlety of software themselves and, on the other hand, to the limitations of the current methodologies. In fact, almost all of the proposed methodologies fail to produce clearly understood and modifiable systems and their use is still considered to be an activity accessible only to specialists with a large array of competencies, skills, and knowledge. This, in turn, leads to highly paid personal, high maintenance costs, and extensive checks needing to be performed on the software. For these reasons, companies are likely to welcome any new methodology promising demonstrable improvement in the software development cycle.

Recently, a new and very promising methodology, called Lyee (read as “lee”, tail-character word of “governmental methodologY for softwarE providencE”) (see, Non-Patent Documents 6, 7, 8, and 9), has been proposed. Intended to deal efficiently with a wide range of software problems related to different fields, Lyee allows the development of software by simply defining its requirements. More precisely, a developer has only to provide words, calculation formulae, calculation conditions (preconditions) and layout of screens and printouts, and then leaves in the hands of the computer all subsequent troublesome programming process (e.g., control logic aspects). Despite its recency, the results of the use of Lyee have shown tremendous potential. In fact, compared to conventional methodologies, development time, maintenance time and documentation volume can be considerably reduced by using Lyee (as much as 70 to 80%) (see, Non-Patent Document 7). In Non-Patent Document 4, we proposed some classical static analysis techniques in order to improve many aspects of this methodology, in particular Lyee requirements.

Nevertheless, since both the semantics of Lyee generated software together with the process of automatic generation of software from requirements are described using informal language, difficulties and confusions may arise when trying to understand and study this methodology. In addition, the ideas behind this methodology are described using a sequential language which is not appropriate to support them. In fact, a Lyee generated software is basically made of small components (called vectors in Lyee terminology), where each one has an atomic goal (goal of the vector), that collaborates together by interaction in order to produce the desired results (global goal: the whole goal). It is, however, commonly known that a process algebra which naturally supports concurrency (a plurality of calculation subjects operate while exchanging information with one another) and communication is the intrinsically appropriate language to specify concurrent components and therefore it will provide a formal and worthy foundation to support the Lyee methodology concepts. Among other benefic consequences of using the process algebra in the Lyee methodology, many components (complete vectors or parts of vectors) of the actual version of Lyee will no longer be required. This is because these components, described by the sequential language, have been required by all means for controlling an order of executing a certain group of processes, but their functions are naturally supported by process algebra which supports the process concurrency and communication. Actually, the routing vectors are no longer needed. Thus, we obtain a formal description of Lyee that is simple and that produce program shorter and consuming less time and memory. Besides, this formal description will be an inevitable start point for many interesting analysis of diverse aspects of this methodology. For instance, to optimize the Lyee generated software or the software generation processes, we need a formal proof that the optimized program is equivalent to its original version. Formal equivalence checking or more generally model checking can be elegantly achieved when using process algebra.

In this paper, we first define a formal process algebra, called Lyee-calculus, that easily and naturally supports the basic concepts of the Lyee methodology. In fact, this calculus can be seen as an abstract machine (abstracted concept of a computer) which is more suitable to support the Lyee methodology concepts than the Von Newman one. This machine considers a program as a set of molecules that interact together to produce a final result. Secondly, we show how this calculus can formalize and simplify both the Lyee components (referred to as vectors in Lyee) together with the whole software generation process of the Lyee methodology. Actually, we have formalize the whole process of the automatic generation of Lyee software generation.

The remainder of this paper is organized as follows. In Section 2, we define the syntax and the semantics of the Lyee-calculus. In Section 3, we give a short and technical introduction to the Lyee methodology and an overview of its formalization using the Lyee-calculus. In Section 4, we propose a detailed and complete formalization of the Lyee methodology using Lyee-calculus. In Section 5, we present one case study that concretely shows both how a program is automatically generated from simple requirement together with a step-by-step description of the execution of the generated program. Finally, Section 6 provides concluding remarks on this work, and discusses some future work.

2. Lyee-Calculus

Process algebra is a formal description technique for complex computer systems, especially those involving communicating, concurrently executing components (see, Non-Patent Document 1, 3, 5). Process algebra is generally referred as calculus in the literature since it involves a variety of mathematical and logic concepts (concurrency theory, operational semantics, complexity theory, logic, etc.) that goes beyond the process algebra field.

In this section, we give the syntax and the semantics of a new calculus, called Lyee-calculus, that we have specially define to formalize the Lyee methodology.

2.1 Syntax

Lyee-calculus programs are systems composed of independent and parallel processes that communicate using hand-shake technique (a technique to achieve communication between two processes by setting one process be ready to receive and the other be ready to send) on named channels. The channel can be restricted so that only some process can communicate on them. A process can send a value ν through a channel ι by doing the action [ι!e] (ν corresponds to the valuation of e). Similarly, a process can receive a value of e from a channel ι by doing the action [ι?e].

A process can also perform a silent action τ. This special action is intended to represent an internal behavior of a system such as synchronization between processes (a phenomenon in communication between processes, where one process sends a value or the like and at the same time the other process receives it). The action is useful to capture indeterminism in process evolution, that is, in a case where there are a plurality of process alternatives, and it cannot be predicted which process is to be executed (refer to the description of “selection” of Process Syntax Definition 1 described later).

The process syntax will be defined as follows.

<Syntax 1> P,Q::=[K].P|(P|Q)|P+Q|PQ|P/L|.A({right arrow over (X)})

P|nil  [eq. 1] <Syntax 2> K,K ₁ ,K ₂ ::={κ}|K ₁ ∪K ₂ <Syntax 3> L,L ₁ ,L ₂::=0|{ι}|L ₁ ⊚L ₂|  [eq. 2] <Syntax 4> κ::=ι!e|ι?e|τ|

The meanings of symbols for use in the above syntaxes and the intuitive meaning of each syntactic construction are as follows.

<Syntax 1> TABLE 1 Symbol Definition P, Q Processes : := The left side of the symbol is defined as the right side | Or [K].P Sequence K Set of actions P | Q Parallel composition P + Q Choice P

Q Guarded choice P/L Restriction ${A\left( \overset{->}{X} \right)}\overset{def}{=}P$ Definition nil nil process

Syntax 1 has the following intuitive meaning. That is, if there are processes P and Q, relations between them and their contents are defined as any of the followings: sequence ([K].P); parallel composition P|Q); choice (P+Q); guarded choice (P

Q); restriction (P/L); definition; and nil process (nil), where the definition $\begin{matrix} \overset{def}{=} & \left\lbrack {{eq}.\quad 3} \right\rbrack \end{matrix}$ means that the left side of this symbol is defined by the right side.

Interpretation of each syntactic constuction will be described later.

<Syntax 2> TABLE 2 Symbol Definition K, K₁, K₂ Set of actions κ Action {κ} Set of a single action (Single action) K₁ ∪ K₂ Union of Sets of actions (Set union)

Syntax 2 has the following intuitive meaning. That is, when there are sets of actions K, K₁ , and K₂, those sets are any of the followings: a set including a single action as an element ({κ}); a union of sets of actions (K₁⊚K₂)

<Syntax 3> TABLE 3 Symbol Definition L, L₁, L₂ Set of channels 0 Empty set ι Channel {ι} Set of a single channel (Single channel) L₁ ∪ L₂ Union of Sets of channels (Set union)

Syntax 3 has the following intuitive meaning. That is, when there are sets of channels L, L₁, and L₂, these sets are any of the followings: an empty set (0), a set including only a single channel as an element ({ι}); a union of sets of channels (L₁⊚L₂).

<Syntax 4> TABLE 4 Symbol Definition κ Action ι!e Send action (send the result of evaluation of the arithmetic expression e on the channel ι) ι?e Receive action (receive the value of the arithmetic expression e on the channel ι) τ Silent action ι,

Channel e Arithmetic expression

Syntax 4 has the following intuitive meaning. That is, when there is an action κ, the action is any of the followings: a transmitting action (ι!e) to send a value of a calculation result of an expression e on a channel ι; a receiving action (ι?e) to receive the value of the expression e on the channel ι; and a silent action (τ).

The meaning of the syntactic construction defined in Syntax 1 will be described in detail.

1) [K].P: Sequence

Process [K].P, where K is a set of actions, is a process that has to perform all the action in K and then behaves as the process P. The order in which the actions in K have to be executed is not important. Notice that for the sake of simplicity we write [κ₁, . . . , κ_(n)] instead of [{κ₁, . . . , κ_(n)}].

2) P|Q: Parallel Composition

Process P|Q behaves as processes P and Q running in parallel. Each one of them may interact with the other on channels known to both, or with the outside world (environment or the end-user) independently from the other. When two processes synchronize (sending of a value or the alike from a certain process and receiving of it by the other process occurs at the same time) on the same channel, the whole process will perform an action τ (silent action) and thereafter behave as the remaining process. For instance, let's take the following process: P=P1|P2

with P1 and P2 defined as follows: $\begin{matrix} {{{P\quad 1}\overset{def}{=}{{\left\lbrack {{\iota!}4} \right\rbrack \cdot P}\quad 1^{\prime}}}{{P\quad 2}\overset{def}{=}{{\left\lbrack {\iota?x} \right\rbrack \cdot P}\quad 2^{\prime}}}} & \left\lbrack {{eq}.\quad 4} \right\rbrack \end{matrix}$

The above equation has an intuitive meaning that P1 is a process which transmits a value 4 to the channel ι, and thereafter behaves as process P1′. P2 is a process which waits until a value of an equation x is given to the channel ι, receives the value when given, and thereafter behaves as process P2′.

Then, process P performs the silent action τ at a time when the processes P1 and P2 are synchronized (actually P1 sends the value 4 and simultaneously P2 receives the value), and behaves as the remaining process P1′|P2′. Semantically, we will note this transition as follows: $\begin{matrix} \left. {P\overset{\tau}{\rightarrow}{P\quad 1^{\prime}}} \middle| {P\quad 2^{\prime}} \right. & \left\lbrack {{eq}.\quad 5} \right\rbrack \end{matrix}$

This equation intuitively means that as a result of an interaction in the process p, the silent action τ is executed, and the whole process shifts to the parallel process P1′|P2′.

The relation, $\begin{matrix} \overset{\kappa}{\rightarrow} & \left\lbrack {{eq}.\quad 6} \right\rbrack \end{matrix}$

will be formally defined later within this section.

3) P+Q: Choice

Process P+Q is the process that behaves as Process P or as Q. The choice of the process to be executed is determined deterministically (made by the environment) if both P and Q do not begin with a silent action, otherwise the choice is not determined.

4) P 9 Q: Guarded Choice

Process P 9 Q is the process that behaves as P until process Q is activated. Whenever the latter Q is activated, P is stopped and cleared from memory.

5) P/L: Restriction

Process P/L is the process that behaves as P except that it can communicate with the environment by use of channels given to a channel set L only.

6) Symbols of Equation 3: Definition

For example, the symbols of Equation 3 can make definitions represented by the following equation. $\begin{matrix} {{A\left( \overset{\rightarrow}{X} \right)}\overset{def}{=}P} & \left\lbrack {{eq}.\quad 7} \right\rbrack \end{matrix}$ wherein A denotes a process identifier, {right arrow over (X)}  [eq. 8]

are variables (parameters) of the Process A, and it is defined that the process of the left side is equal to the process P of the right side. The process P may recursively involve A.

7) Nil: Nil Process

Nil is the process that cannot perform any action. In other words, this is a dead process.

When a certain process ends, the process usually turns to a nil process. When a process ends, thereby resulting in a nil process, the process is not activated any more. Therefore, even if conditions for executing an action are satisfied, any action cannot be executed.

2.2 Modeling of Process to Hold Value

In this section, we show how to model a value-holding cell of memory as a process that interacts with its environment through its communication channels. As shown by FIG. 1, we consider that the memory cell has two ports (channels) of communication, in and out. The basic task of this memory cell is to infinitely wait a value on channel in and to make it available on channel out. The memory cell may output the same value to the channel out as much as necessary until a new value is input into the channel in. The channels themselves do not hold any value.

We write the process cell C^(x)(ν)), meaning that the memory cell x holds the value ν, as follows: $\begin{matrix} {{C^{x}(\upsilon)}\overset{def}{=}{{\left\lbrack {{in}^{x}?y} \right\rbrack \cdot {C^{x}(y)}} + {\left\lbrack {{{out}^{x}!}\upsilon} \right\rbrack \cdot {C^{x}(\upsilon)}}}} & \left\lbrack {{eq}.\quad 9} \right\rbrack \end{matrix}$

This formal description intuitively means that the process C^(x)(ν) holding the value ν behaves as a process C^(x)(y) (i.e., the held value is changed from ν to the value of the equation y), when receiving the value of the equation y in a channel in^(x). When the held value ν is communicated to a channel out^(x), the process behaves as the process C^(x)(ν) while holding the value ν even after the transmitting action.

By capturing a memory cell as a process holding the value, we can further add intelligence to it. For instance, we can write a cell that does not allow the access to its contents until it will be initialized (initial value is received). This smart cell having an information processing capability can be defined as follows: $\begin{matrix} {{{Cell}\quad(x)}\overset{def}{=}{\left\lbrack {{in}^{x}?y} \right\rbrack \cdot {C^{x}(y)}}} & \left\lbrack {{eq}.\quad 10} \right\rbrack \end{matrix}$

A process Cell(x) is a process which behaves as a process C^(x)(y) holding the value of the equation y, after receiving the value of the equation y in the channel in^(x) (the process receives the value in the equation y, holds the value of the equation y, and does not transmit any value).

Now, giving two processes defined as follows: $\begin{matrix} {{{P\quad 1}\overset{def}{=}{\left\lbrack {{{in}^{x}!}5} \right\rbrack \cdot {nil}}}{{P\quad 2}\overset{def}{=}{\left\lbrack {{out}^{x}?y} \right\rbrack \cdot {nil}}}} & \left\lbrack {{eq}.\quad 11} \right\rbrack \end{matrix}$

The process P1 is a process (process to transmit value 5) which transmits a value 5 to the channel in^(x), and turns to nil (ends). The process P2 is a process (process to receive the value in the equation y) which turns to nil (ends) after receiving the value of the equation y in the channel out^(x).

It is easy to write a program where these two processes communicate through a cell x (C^(x)): P1|Cell(x)|P2

This program is a program in which the processes P1, Cell(x), and P2 are executed in parallel.

FIG. 2 shows interactions among all the above involved processes.

Here are the different steps of that program execution: $\begin{matrix} \begin{matrix} {\left. {P\quad 1} \middle| {{Cell}\quad(x)} \middle| {P\quad 2} \right. = \left. {\underset{\_}{\left\lbrack {{{in}^{x}!}5} \right\rbrack} \cdot {nil}} \middle| {\underset{\_}{\left\lbrack {i\quad{n^{x}?y}} \right\rbrack} \cdot {C^{x}(y)}} \middle| {\left\lbrack {{out}^{x}?y} \right\rbrack \cdot} \right.} \\ {\left. {{nil}\overset{\tau}{\rightarrow}{C^{x}(5)}} \middle| {\left\lbrack {{out}^{x}?y} \right\rbrack \cdot {nil}} \right.} \\ {= \left. \begin{pmatrix} {{\left\lbrack {{in}^{x}?y} \right\rbrack \cdot {C^{x}(y)}} +} \\ {\underset{\_}{\left\lbrack {{{out}^{x}!}5} \right\rbrack} \cdot {C^{x}(5)}} \end{pmatrix} \middle| {\underset{\_}{\left\lbrack {{out}^{x}?y} \right\rbrack} \cdot} \right.} \\ {{nil}\overset{\tau}{\rightarrow}{C^{x}(5)}} \end{matrix} & \left\lbrack {{eq}.\quad 12} \right\rbrack \end{matrix}$

The above equation intuitively means that the process P1|Cell(x)|P2 is executed through the following first and second steps. An underline indicates a transmitting/receiving action which causes the interaction (synchronization) (the right side denoted with an equal symbol indicates one step).

<First Step>

Three processes are performed in parallel: (1) [in^(x)!5].nil (transmitting value 5 to channel in^(x)); (2) [in^(x)?y].C^(x)(y) (receiving the value to be given to the equation y in the channel in^(x), and holding the value of the equation y in a cell x after the receiving); and (3) [out^(x)?y].nil (receiving the value of the equation y in the channel out^(x)). As a result, the interaction (synchronization) among the processes occurs: (1) completes the transmission of the value 5 to the channel in^(x) at the same time (2) receives the value 5 in the channel in^(x), and the silent action τ is executed. The process shifts to a parallel process of two processes: (4) C^(x)(5) (holding the value 5 in the cell x); and (3) [out^(x)?y].nil (receiving the value of the equation y in the channel out^(x)).

<Second Step>

From the above definition of the equation 9, (4) C^(x)(5) can be replaced with a selection process (4)-1 ([in^(x)?y].C^(x)(y)+[out^(x)!5].C^(x)(5)). That is, the processes (4)-1 and (3) are performed in parallel. As a result, the interaction (synchronization) occurs: (3) (receiving the value 5 of the equation y in the channel out^(x)) occurs simultaneously with (4)-1 [out^(x)!5].C^(x)(5) (transmitting the value 5 to the channel, and the silent action τ is executed. As a result, the remaining process behaves as C^(x)(5) (holding the value 5 in the cell x).

2.3 Semantics

Hereafter, we give the formal semantics of the Lyee-calculus. This semantics is defined by the interaction relation, $\begin{matrix} \overset{\kappa}{\rightarrow} & \left\lbrack {{eq}.\quad 13} \right\rbrack \end{matrix}$

At this time, an operator → denotes a “relation”, and κ denotes an action. The “relation” is a set of a plurality of “relations”, and each “relation” which is an element of a set is constituted of the following three constituents. A first constituent is a “process before changed”, a second constituent is a “process after changed”, and a third constituent is an “action executed during the change”. $\begin{matrix} {P\overset{\kappa}{\rightarrow}Q} & \left\lbrack {{eq}.\quad 14} \right\rbrack \end{matrix}$ wherein the three constituents of the relation → are (P, Q, K).

In the above definition, the equation 14 means that there is a reaction amongst the sub-process P such that the whole process can execute the atomic action (a series of undivided actions that does not permit any interrupt, and has to be necessarily completed in order to start the next action separately) κ and becomes the sub-process Q. The interaction relation is an original idea inspired by the Chemical Abstract Machine of Berry and Boudol (see, Non-Patent Document 2). In this model, a process is considered as a chemical solution of molecules waiting to interact.

To formally introduce the relation of the equation 13, we need to define the following notions: $\begin{matrix}  & \left\lbrack {{eq}.\quad 15} \right\rbrack \end{matrix}$

The above is a symbol for use in simplifying the process, and indicates that the left side is equal to the right side which is a simplified process. The process can be simplified by eliminating the nil process as follows: $\begin{matrix} \begin{matrix} {P❘{{nil}P}} & {{nil} + {PP}} & {{nil} \vartriangleright {PP}} \\ {{nil}❘{PP}} & {P + {{nil}P}} & {P \vartriangleright {{nil}P}} \\ \quad & \quad & \quad \\ \quad & {{{nil}/L}{nil}} & \quad \end{matrix} & \left\lbrack {{eq}.\quad 16} \right\rbrack \end{matrix}$

[[e]]  [eq. 18]

We denote by

[[e]] the set of values containing the result of the evaluation of the expression e. If e is a variable, a domain of the value of its evalutaion is the same as that of the variable (integral, real, etc.). For the sake of simplicity of the description, we consider that all variables belong to the real set. κι is the name of the channel used by the action κ, i.e: τ_(ι)=∅ (

!e)_(ι)=(

?e)_(ι)={

}  [eq. 19]

The equation means that since there does not exist any channel used by the silent action τ, the set is an empty set (0). A channel used by a transmitting action (ι!e) and a receiving action (ι?e) is ι.

A set of the “relations” (→) has, as elements, the least relation that satisfies 15 rules given by Table 5.

Various R symbols within parentheses are symbols indicating rule names. Each rule includes premises and a result, and obtains a result shown in the lower part of a horizontal line at a time when premises in the upper part are satisfied. TABLE 5 ( R ) ⁢ P ⁢ -> κ ⁢ Q ′ ⁢   ⁢ Q ′ ⁢   ⁢ ⁢   ⁢ Q P ⁢ -> κ ⁢ Q $\left( R_{!} \right)\frac{\upsilon \in {〚e〛}}{{\left\lbrack {\iota\text{!}e} \right\rbrack.P}\overset{{\iota!}\upsilon}{->}P}\quad\left( R_{?} \right)\frac{\upsilon \in {〚e〛}}{{\left\lbrack {\iota\text{?}e} \right\rbrack.P}\overset{\iota?\upsilon}{->}{P\left\lbrack {\upsilon\text{/}e} \right\rbrack}}\quad\left( R_{\tau} \right)\frac{\upsilon \in {〚e〛}}{{\lbrack\tau\rbrack.P}\overset{\tau}{->}P}$ ${\left( R_{\lbrack\rbrack} \right)\frac{{\left\lbrack K_{1} \right\rbrack.P}\overset{\kappa}{->}P^{\prime}}{{\left\lbrack {K_{1}\bigcup K_{2}} \right\rbrack.P}\overset{\kappa}{->}{\left\lbrack K_{2} \right\rbrack P^{\prime}}}K_{2}} \neq 0$ $\left( R_{+}^{\prime} \right)\frac{P\overset{\kappa}{->}P^{\prime}}{{P + Q}\overset{\kappa}{->}P^{\prime}}\quad\left( R_{+}^{\tau} \right)\frac{Q\overset{\kappa}{->}Q^{\prime}}{{P + Q}\overset{\kappa}{->}Q^{\prime}}$ $\left( R_{\vartriangleright}^{\tau} \right)\frac{P\overset{\iota?\upsilon}{->}{{P^{\prime}\quad Q}\overset{{\iota!}\upsilon}{->}Q^{\prime}}}{{P \vartriangleright Q}\overset{\tau}{->}Q^{\prime}}\quad\left( R_{\vartriangleright}^{l} \right)\frac{P\overset{\kappa}{->}P^{\prime}}{{P \vartriangleright Q}\overset{\kappa}{->}{P^{\prime} \vartriangleright Q}}\quad\left( R_{\vartriangleright}^{\tau} \right)\frac{Q\overset{\kappa}{->}Q^{\prime}}{{P \vartriangleright Q}\overset{\kappa}{->}Q^{\prime}}$ $\left( R_{❘}^{\tau} \right)\frac{P\overset{\iota?\upsilon}{->}{{P^{\prime}\quad Q}\overset{{\iota!}\upsilon}{->}Q^{\prime}}}{P❘{{Q\overset{\tau}{->}P^{\prime}}❘Q^{\prime}}}\quad\left( R_{i}^{l} \right)\frac{P\overset{\kappa}{->}P^{\prime}}{P❘{{Q\overset{\kappa}{->}P^{\prime}}❘Q}}\quad\left( R_{❘}^{\tau} \right)\frac{Q\overset{\kappa}{->}Q^{\prime}}{P❘{{Q\overset{\kappa}{->}P}❘Q^{\prime}}}$ ${\left( R_{=} \right)\frac{{P\left\lbrack {\overset{->}{Y}/\overset{->}{X}} \right\rbrack}\overset{\kappa}{->}P^{\prime}}{{A\left( \overset{->}{Y} \right)}\overset{\kappa}{->}P^{\prime}}{A\left( \overset{->}{X} \right)}} = {{{P{\quad\quad}\left( R_{/} \right)}\frac{P\overset{\kappa}{->}P^{\prime}}{{P/L}\overset{\kappa}{->}{P/L}}\kappa_{l}} \in L}$

For example, the second rule (R_(!)) means that in a case where the value ν belongs to a set of values of the expression e (the upper-part premises are satisfied), [ι!e].P, that transmits the value of the expression e to the channel ι and then becomes the process P, shifts to the process P after action of sending the value ν to the channel ι occurs, turns to the process P (result of the lower stage).

3. Informal Formalization of Lyee Requirements

This section presents an overview of how the Lyee methodology generates software from simple user requirements.

Besides, through this overview we progressively introduce how one can simply and efficiently formalize this methodology using the Lyee-calculus. The complete formalization of the process of software generation of the lyee methodology will be given in the next section.

3.1 Lyee Requirements

Within the Lyee methodology, requirements are given in a declarative way as a set of statements containing elements such as words together with their definitions, their calculation conditions and their attributes (input/output, types, security attributes, etc.). Table 6 gives an example of Lyee requirements.

In the table, “word” indicates a word name, “Definition” indicates a definition expression for generating a value of the word, “Condition” indicates calculation conditions to execute the definition expression, and “IO” indicates attributes of input/output of the value of the word. “OF” indicates an output to a file, “OS” indicates an output to a screen, “IS” indicates an input from a screen, and IF (not shown) denotes an input from a file. “Type” denotes an attribute of the value, where “int” indicates an integer and “float” indicates a floating-point number. “Security” denotes an attribute relating to security of the value. “secret” indicates non-public level, and “public” indicates public level. TABLE 6 Word Definition Condition IO Type Security . . . a b + c b * e > 2 OF int secret c IS float public b 2 * c + 5 c > 0 OS float public e IS float public . . .

The requirements given in Table 6 correspond intuitively, in a traditional programming language, to the code given in Table 7. S_(a) denotes a statement of a word a. TABLE 7 Statement Code S_(a) if b*e>2 then a:=b+c; output(a); end if S_(c) input(c); S_(b) if c>0 then b:=2*c+5; output(b); end if S_(e) input(e);

For example, a code of the statement S_(a) of the word a means that “if b*e>2 is true, a calculation result of b+c is substituted into the word a, and the value of the word a is output”.

A code of a statement S_(c) means “inputting the value into a word c”.

Within the Lyee methodology, the user does not need to specify the order (control logic) in which these definitions will be executed. As shown in Table 7, despite the fact that the definition of word a uses word b, statement s_(b) is listed after the statement s_(a). As explained in the sequel, from these requirements, and independent of the order of statements, Lyee is able to generate code that computes all the defined words. This simple idea has, as shown in Non-Patent Document 6, 7, 8, and 9, multiple beneficial consequences on the different steps of software development. In fact it allows us to begin developing software even with incomplete requirements. Moreover, the user does not need to deal with any control logic of the order of executing the words unlike more classical methodologies. The control logic part of the software will be, within the Lyee methodology, automatically generated, reducing consequent programming errors and time. Flexibility is also a major benefit of the Lyee methodology since the maintenance task can be reduced to a simple modification of requirements (add, remove and/or modify words' definitions).

Consequently, Lyee systems can be viewed as collections of independent components (statements) that interact together in order to produce the desired result. In this paper, the concepts of our process algebra agree very well with this view. This is because the Lyee-calculus regards a program as a chemical solution of molecules (processes) that mutually interact together to reach the final goal. So, at a first glance, one can view a Lyee requirement LR composed of a set of statements {s_(i), . . . , s_(n)} as a concurrent processes of the Lyee-calculus as follows. LR=s ₁ | . . . |s _(n)

This will be intuitively described. A requirement LR is a process in which processes s₁ to S_(n) are executed in parallel.

3.2 Pallets and Basic Structure (Scenario Function)

From the requirements in Table 6, a program can be automatically generated that computes the values of a and b and outputs them. This program will simply repeat the execution of these instructions until a fixed point is reached, i.e. any other iteration will not change the value of any word as shown in FIG. 3.

From the process algebra view point, the notion of “reaching of a fixed point” is naturally implemented within the semantic. In fact, the processes (molecules) interact together until a state of no possible evolution (fix point) is reached.

Let's be more precise about the structure and the content of the program that will be automatically generated by Lyee from requirements. Within the Lyee methodology, the execution of a set of statements, such as the ones given in Table 6, is accomplished in a particular manner. In fact, Lyee distributes the code associated with statements over three spaces, called Pallets (W₀₂, W₀₃ and W₀₄) in the Lyee terminology, as shown in FIG. 4.

Pallet W₀₂ processes the input words.

Pallet W₀₃ computes the calculation conditions of the words and saves the results in boolean variables (having a true/false value). For instance, the calculation condition “b*e>2” used in the definition of the word “a” is calculated in W₀₃ and the true/false result is stored in another variable “a_cond”.

Pallet W₀₄ deals with the calculation of the words by their definition given in the requirements. Pallet W₀₄ also outputs the calculated values of the words.

Starting from pallet W₀₄, a Lyee program tries to compute the values of all the defined words until a fixed point is reached. Once there is no evolution in W₀₄ concerning the computation of the word values, control is given, by routing vector R4C, to pallet W₀₂. In its turn, this second pallet tries repeatedly to input values of words until a fixed point is reached (no other inputs are available) and then, by routing vector R2C, transfer the control to pallet W₀₃. Finally, and similar to pallet W₀₄, pallet W₀₃ tries to compute the calculation conditions of the words according to the requirements until a fixed point is reached. As shown in FIG. 5, this whole process (W₀₄→W₀₂→W₀₃) will repeat until a situation of overall stability is reached and the three pallet linked together are called Basic Structure (Scenario Function).

Using a sequential language to implement a Lyee requirement forces the author of the Lyee methodology to explicitly specify the order in which the pallet will be executed, the order according to which vectors (modules) in the same pallet have to be executed and how to pass control from one vector to another. In other words, this sequential language forces the introduction of some aspects that do not belong to fundamental ideas of the Lyee methodology, and that they have considerably complicated this methodology. That is, it is necessary to control repeated execution of the vectors in the pallets, and it is necessary to designate a way, time and the like for transferring the execution from one pallet to another (including transfer between different basic structures). For this purpose, there have been introduced pallet functions (controlling executions in the pallet), routing vectors (determining the pallet to be executed next), and a pallet chain relation (controlling executions between the pallets).

However, using the Lyee-calculus, we do not need any more to specify the order according to which the pallets will be executed, the order according to which the vectors of each pallet will be executed, how and when to pass control from one pallet to another, etc. All such details will be, needless to say, naturally managed by the abstract machine of the Lyee-calculus in this paper. Consequently, a Basic Structure (Scenario Function) could be formalized as follows: SF=W ₀₄ |W ₀₃ ″W ₀₂

That is, the process of a basic structure SF is a parallel process of processes of three pallets W₀₄, W₀₃, and W₀₂.

Notice that the order according to which W₀₄, W₀₃ and W₀₂ is no more important and the routing vectors that connect these pallets are also eliminated.

Lyee has established a simple program with a fixed structure (called a Predicate Vector in the Lyee terminology) that makes the structure of generated code uniform and independent of the requirement content. A pallet function as global program to control executions of vectors simply calls predicate vectors. The structure of a predicate vector is as shown in FIG. 6.

The goal of a predicate vector changes from one pallet to another.

<Pallet W₀₄>

In the pallet W₀₄, the first goal is to give a value to a word according to its definition. The predicate vector that performs this function is referred to as L4. The predicate vectors of the words “a” and “b” in the example shown in FIG. 4, are as shown in FIG. 7.

Once there is no evolution in the calculation of the words, the Lyee generated code tries to output the words which will be the next goal. The predicate vector having a goal of outputting values is called as an output action element (output vector: O4).

Additionally, there is a structural action element (referred to as S4) that clears a region.

<Pallet W₀₂>

In pallet W₀₂, we find two predicate vectors having the goals of associating values with input words. The vectors include: an input action vector (referred to as I2) which inputs values to a main memory (outside of the Lyee program region); and L2 which checks attribute of a value and inputs it into the Lyee program region.

<Pallet W₀₃>

In pallet W₀₃, The goal of the predicate vector L3 is to compute a condition for executing the definition (i.e., L4) of the word, which are specified within requirements as shown in FIG. 8.

Finally, the Lyee program associated with the requirements given in Table 6 is as shown in Table 8.

One pallet function disposed in each pallet calls (activates) the predicate vectors in the pallet. The pallet functions are called by one pallet chain function disposed in the program. The pallet chain function calls the corresponding pallet function in accordance with designations by R4, R2, and R3 of the pallets. Meanings of other vector programs are as shown in comments in Table 8. A processing object of each predicate vector L4, L2, and L3 (referred to generically as a signification vector) is a word, and a processing object of the input/output vector (I2 and O4) and the structural vector (S4) is a set of words. TABLE 8 Pallet Program Comments W₀₄ Call S4 Initialize memory area Do  Call L4 a Calculate the definition of the word a  Call L4 b Calculate the definition of the word b while a fixed point is not reached Repeat until a fixed point is reached  Call O4 Output the results  Call R4 Designate W₀₂ as the next route W₀₂ Call I2 Input (to the memory) Do  Call L2 e Input the word e  Call L2 c Input the word c while a fixed point is not reached Repeat until a fixed point is reached Call R2 Designate W₀₃ as the next route W₀₃ Do  Call L3 a Calculate a_cond(the condition of the word a)  Call L3 b Calculate b_cond(the condition of the word b) while a fixed point is not reached Repeat until a fixed point is reached Call R3 Designate W₀₄ as the next route

Now, using the Lyee-calculus, W₀₄, W₀₃ and W₀₂ can be specified as follows: W ₀₄ =S4|L4_(—) a|L4_(—) b|O4 W ₀₃ =L3_(—) a|L3_(—) b W ₀₂ =L2_(—) e|L2_(—) c|I2

The W₀₄ process is a parallel process of processes S4, L4_a, L4_b, and O4.

The W₀₃ process is a parallel process of processes L3_a and L3_b.

The W₀₂ process is a parallel process of processes L2_e, L2_c, and I2.

The formal definition of the different vectors (L2, L3, L4, I₂, O₄, S4, etc.) will be given in the next section.

3.3 Process Route Diagrams

The Scenario Function presented in the previous section can be a complete program for a simple case of given requirements, particularly when all the input and output words belong to the same screen and there is no use of any database. If we need to input and output words that belong to databases or to different screens interconnected together, then the situation will be more complicated. For the sake of simplicity, we deal, in the sequel, only with the case when we have many screens. Suppose for instance that we have three interconnected screens, as shown in FIG. 9, allowing a user to navigate from one to another. Suppose in each one of them the user can input, compute and output words. Therefore, in the specification, the user must specify how these screens are interconnected.

Furthermore, it is not convenient to define only one scenario function in which we compute all the words defined in all the screens. This is because in fact, some screens may not be visited for a given execution of the program and then the computation of the value of their words that have not been visited will be lost. For that reason, Lyee associates with each screen its owner scenario function that will be executed only if this screen is visited. The scenario functions associated with screens are connected together showing the move from one of them to another. In the Lyee terminology, many scenario functions connected together make up a Process Route Diagram as shown in FIG. 10.

Using the Lyee-calculus, we can formalize a screen s_(k) as a process Φ(s_(k)) that control the execution of the process SF(s_(k)) as follows: Φ(s _(k))=SF(s _(k))

[

^(s) ^(k) ?1].Φ(s _(k))  [eq. 21]

That is, the process Φ(s_(k)) behaves as the process SF(s_(k)) (process having a basic structure of the processing relating to a screen s_(k)). When the process receives a true value in a channel ι^(sk), the process stops SF(S_(k)), and behaves as the process Φ(s_(k)). In actual movement, the control process Φ(s_(k)) actives the process SF(s_(k)). When the control process Φ(s_(k)) receives a signal on the channel ι^(sk) associated to the screen s_(k) (i.e., when the screen s_(k) is reactivated), the control process itself is reactivated. Therefore, when the control process Φ(s_(k)) is reactivated, SF(S_(k)) once ends, and is reactivated, thereby returning to a fresh instance.

A concrete example will be given later in this paper to show how the function Φ(s_(k)) works.

3.4 Lyee Program

To summarize, a Lyee program by the Lyee methodology has the following structure. The Lyee program contains several process route diagrams (PRD). Each of them is a set of interconnected scenario functions (SF). Each scenario function contains three interconnected pallets W₀₂, W₀₃ and W₀₄. Finally, the pallet contains predicate vectors.

Since the predicate vectors are modules of minimum units of the Lyee program, the predicate vectors are also referred to as atomic vectors. The predicate vectors include signification vectors (generic term of L2, L3, and L4) and action vectors (generic term of I2, O4, S4, R2, R3, and R4). As a control module which controls the execution of these predicate vectors, each pallet is provided with a pallet function. As a module which controls the execution of the pallet function, a program is provided with one pallet chain function.

Using the Lyee-calculus, a Lyee program P containing the screens s₁, . . . , s_(k), is formalized as follows: P(s ₁ , . . . , s _(k))=Ψ(s ₁ , . . . , s _(k))/

(s ₁ , . . . , s _(k))  [eq. 22] where L(s₁, . . . , s_(k)) is the set of input and output channels. This restricts (s₁, . . . , s_(k)) to communicate with the environment only on channels in L(s₁, . . . , s_(k)).

The function Ψ is defined as follows: Ψ(s ₁ , . . . , s _(k))=(|_(s∈{s) ₁ _(, . . . , s) _(k) _(})[

^(s)?1].Φ(s))

[

^(s) ⁰ ?1].nil  [eq. 23]

This function Ψ activates a process Φ(s) in order to activate SF(s) corresponding to a screen s_(k) whenever a true value is received on the corresponding channel ι^(s) corresponding to the screen s (s is one of screens s₁, . . . , s_(k)). The channel ι^(s) formalizes a button or a menu item that a user may use to activate the corresponding screen. When the function Ψ receives a true value on a channel ι^(s0), the function Ψ kills all other processes, and the function itself also ends (turns to nil). The channel ι^(s0) formalizes the Exit button (or a corresponding menu item).

Consequently, a Lyee system can be viewed as a collection of independent concurrent processes that communicate with each other to compute the desired output words. In contrast with conventional sequential view of Lyee methodology, there is no need for all routing vectors. The role of the control function is largely simplified. There is no need of working memory areas, etc. More details about Ψ(s₁, . . . , s_(k)) together with concrete examples will be given in the sequel.

The next section gives a more detailed and complete formalization of the Lyee methodology.

4. Formalization of the Lyee Methodology

There will be described how to automatically generate software from a simple user requirement by use of the Lyee-calculus.

It is assumed that the user requirement includes k screens {s₁, . . . , s_(k)}. It is also assumed that each screen includes a set of statements. In this case, each statement has a format (w, e, c, InOut, type), wherein: w denotes a word name; e denotes a definition expression; c denotes a condition for execution of the definition expression; InOut designates whether the word is input, output, both, or neither (the value i is used for input, the value o is for output, the value io is for both input and output, and an empty field is used for neither input nor output); and type denotes an attribute (type) of a value (e.g., type B is assigned as a symbol indicating a button).

To define the program P (s₁ , . . . , s_(k)) on this requirement, signification and action vectors (processes) are formalized as shown in the following table.

First, undefined symbols used in the formalization will be described.

Let Use(e) denotes the set of words used in the expression e. For instance, Use (a*b+1)={a, b}. Also, F(S) is a function which takes a set of input values for variable S and which returns a set of receiving actions to input those values. F(∅)=∅  [eq. 24] F({x}∪A)={

₄ ^(x) ?x}∪F(A)

The above has the following meaning:

When there is not any input value ((F(0)), there is not any receiving action (0 is an empty set).

A receiving action (F({x}∪A)) having input values x and A is a union set of receiving actions, one of which is to receive a value of x on the channel of

₄ ^(x)  [eq. 25] and the other is a receiving action F(A) to receive input A.

The signification vectors are shown in Table 9. TABLE 9 Vector Comments L₄ (x, e) = <L₄ of Word x which Definition is e   (InOut attribute of its Statement is ‘o’) > [ι₃^(x)?1]⋅ Wait to receive the value true (1) on the channel ι₃^(x) (from L₃) [ℱ(Use(e))]⋅ Wait to receive the vale of all the Use of e form the memory [₄^(x)\!e]⋅ Evaluate e and put the result in the memory cell of x nil finish L₃ (x, c) = <L₃ of Word x which Condition is c   (InOut attribute of its Statement is ‘o’ or ‘io’) > [ℱ(Use(c))]⋅ Wait to receive the value of all the Use of c from the memory [ι₃^(x)\!c]⋅ evaluate c (its value is Boolean) and send the result on the channel ι₃^(x)  (to L₄) nil finish L₂ (x) = <L₂ of Word x   (InOut attribute of its Statement is ‘i’) > [ι₂^(x)?x]⋅ Wait to receive the value of x on the channel ι₂^(x) (from the input vector) [₄^(x)\!x]⋅ Send the value of x on the channel of ₄^(x)  (save the value of x in the memory cell of x) nil finish

The action vectors are shown in Table 10. TABLE 10 Input Vector Comments I₂ (x) = <I₂ of input words group which element is {x} > [d_(x)?x]⋅ Wait to receive a value for Word x on the input channel d_(x) [ι₂^(x)\!x]⋅ Send the value of x on the channel ι₂^(x)  (to L₂) nil finish Output Vector Comments O₄ (x) = <O₄ of output words group having the element {x} > [ι₄^(x)?x]⋅ Wait to receive the value of x from the memory [d_(x)\!x]⋅ Send the value of x on the output channel d_(x) nil finish Structural Vector Comments S₄ (x) = <S₄ of Word x> [₄^(x)?y] ⋅ S₄^(x)(y) Wait to receive any value. Cannot send any value until you receive any value. Once receive a value (it is called ‘initialization’), save the value and behave as S₄^(x)(y). S₄^(x)(y)= [₄^(x)?z] ⋅ S₄^(x)(z) + [ι₄^(x)\!y] ⋅ S₄^(x)(y) If you receive a new value z, behave as S₄^(x)(z) (change the content of the cell x). If you send y which has been saved, behave as S₄^(x)(y) (do not change the content of the cell x). In other word, once you receive and save a value, you can send it other than receiving and saving. Routing Vector Comments R₃(b, e, s) = <R₃ of Word b (Button b)> [d_(b)?clik]⋅ Wait until the button b be pushed [ℱ(Use(e))]⋅ Evaluate the condition of the button b [ι^(s)\!e]⋅ Send the result to the screen s (in other words, acti- vate s if e = 1(true) nil finish

Among the vectors, S₄ is a memory cell which holds a value as described in 2.2, and it is a smart cell having an ability to “prevent the content from being accessed until the value is initialized (an initial value is received)”.

A routing vector is a naturally unnecessary process in the Lyee-calculus, but the element is described in order to show a way of formalization by the Lyee-calculus.

Pallet:

The three pallets W₀₂, W₀₃ and W₀₄ of a given screen s are formalized as follows: W ₀₂(s)=|_((w,*,*,i B)∈s) I ₂(w)|_((w,*,*,i, B)∈s) L ₂(w)  [eq. 26] W ₀₃(s)=|_((w,*,c,*, B)∈s) L ₃(w,c)|_((w,e,c,i,*,B)∈s) R ₃(w,c,e) W ₀₄(s)=|_((w,*,*,*, B)∈s) S ₄(w)|_((w,e,*,*, B)∈s) L ₄(w,e))|_((w,*,*,o,*,*)∈s) O ₄(w) where B  [eq. 27] denotes any type except B (B denotes the button), that means complementary of B, and * denotes anything. Scenario Function:

The scenario function, SF(s)of the screen s is formalized as follows: SF(s)=W ₀₄(s)|W ₀₃(s)|W ₀₂(s)  [eq. 28] Control Function:

The control function attached to a screen s, is formalized as follows: Φ(s)=SF(s)

[

^(s) ^(k) ?1].Φ(s)  [eq. 29]

The control function attached to a set of screens is formalized as follows: Ψ(s ₁ , . . . , s _(k))=(|_(s∈{s) ₁ _(, . . . , s) _(k) _(})[

^(s)?1.]Φ(s))

[

^(s) ⁰ ?1].nil  [eq. 30]

We suppose that s₀ is the screen that we find when we exit the program (exit screen that does not belong to the screens of the program itself).

Here, roles of the control function are summarized as follows. TABLE 11 Control Function function Ψ Place one for It is activated by the end-user and is killed when each program it receives the true value from Finish button being pushed. When it receives the value true from a button pushed by the end-user, it activates the Φ corresponding to the button. When it receives the value true from Finish button, it kills all Φs before kills itself. Φ Place one for It is activated and killed by Ψ. each SF When it receives the value true on the designated channels from a button being pushed by the end-use, it activates the corresponding SF.

In this paper, as one of methods of realizing the Lyee-calculus, a single SF is disposed in a screen, and such single SF is formalized so as to contain all processes of input/output and calculation relating to the corresponding screen. Therefore, a single control function Φ of the SF is disposed to a single screen. However, it is also a possible alternative to formalize the screen so that a plurality of SFs and control functions Φ are disposed to a single screen. Implementation methods may be determined by efficiency of the program.

Lyee Program:

Finally, the Lyee program P(s₁, . . . , s_(k)) associated with the requirement containing the screens s₁, . . . , s_(k) is as follows: P(s ₁ , . . . , s _(k))=Ψ(s ₁ , . . . , s _(k))/

(s ₁ , . . . , s _(k))  [eq. 31] where the set L(s₁, . . . , s_(k)) contains all the input and output channels and it is defined as follows: $\begin{matrix} {{\mathcal{L}\left( {s_{1},\ldots\quad,s_{k}} \right)} = {\left( {\bigcup\limits_{{{({w,{*{,{*{,{i/o},}}}}}}{*)}} \in s_{k}}\left\{ d_{w} \right\}} \right)\bigcup\left\{ \iota^{s_{1}} \right\}}} & \left\lbrack {{eq}.\quad 32} \right\rbrack \end{matrix}$

The meaning of i/o is that this field has to contain the value i, o or io. We suppose also that s₁ is the first screen that appears when the user runs this program.

EXAMPLE 1

5. Case Study 1

In this section, we give a concrete example and describe step by step how a Lyee program progress in order to compute words within our Lyee-calculus.

The example that we present contains only one screen (another example with two screens is given in the appendix). As shown by the requirement given in Table 12, a user can input a word a, waits for the value of b and then exit the screen by pushing the button B₀. FIG. 11 illustrates such a screen. TABLE 12 Word Definition Condition IO Type a i real b 2 * a a > 0 o real B₀ S₀ Click i B

This screen s₁ is composed from three statements: s ₁={(a,,,i,real),(b,2*a,a>0,o,real),(B ₀ ,s ₀,Click,B)}  [eq. 33]

According to the definition of a generic Lyee program given in the previous section, the Lyee program associated to the requirement given by Table 12 is as follows: $\begin{matrix} {{{{SF}\left( s_{1} \right)} = {{W_{04}\left( s_{1} \right)}❘{{W_{03}\left( s_{1} \right)}❘{W_{02}\left( s_{1} \right)}}}}{\Phi\left( s_{1} \right)} = {{{SF}\left( s_{1} \right)} \vartriangleright \left\lbrack {{\iota^{s_{1}}?{{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}{\Psi\left( s_{1} \right)}}} = \left( {\left\lbrack {\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}} \right) \vartriangleright \left\lbrack {{\iota^{s_{0}}?{{\left. 1 \right\rbrack \cdot {nil}}{\mathcal{L}\left( s_{1} \right)}}} = {{\left\{ {d_{a},d_{b},d_{B_{0}},\iota^{s_{1}}} \right\}{\mathcal{P}\left( s_{1} \right)}} = {{\Psi\left( s_{1} \right)}/{\mathcal{L}\left( s_{1} \right)}}}} \right.} \right.} \right.}} & \left\lbrack {{eq}.\quad 34} \right\rbrack \end{matrix}$

wherein W₀₂(s₁), W₀₃(s₁) and W₀₄(s₁) are as shown hereafter. As described above, since the process of R₃ is not essential in the Lyee-calculus, it can be omitted. TABLE 13 W₀₂(s₁) = L₂(a) | I₂(a) $\begin{matrix} {{L_{2}(a)} = {\left\lbrack {\iota_{2}^{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {_{4}^{a}\text{!}a} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{I_{2}(a)} = {\left\lbrack {d_{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{2}^{a}\text{!}a} \right\rbrack \cdot} \\ {nil} \end{matrix}$ W₀₃(s₁) = L₃(b, a > 0) | R₃(B₀, click, s₀) $\begin{matrix} {{L_{3}\left( {b,{a > 0}} \right)} = {\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{3}^{b}\text{!}\left( {a > 0} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{R_{3}\left( {B_{0},{click},s_{0}} \right)} = {\left\lbrack {d_{B_{0}}\text{?}{click}} \right\rbrack \cdot}} \\ {\left\lbrack {\iota^{s_{0}}\text{!}1} \right\rbrack \cdot} \\ {nil} \end{matrix}$ W₀₄(s₁) = S₄(a) | S₄(b) | L₄(b, 2*a) | O₄(b) $\begin{matrix} {{S_{4}(a)} = {\left\lbrack {_{4}^{a}\text{?}a} \right\rbrack \cdot}} \\ {S_{4}^{a}(a)} \\ {{S_{4}(b)} = {\left\lbrack {_{4}^{b}\text{?}b} \right\rbrack \cdot}} \\ {S_{4}^{b}(b)} \end{matrix}$ $\begin{matrix} {{L_{4}\left( {b,{2*a}} \right)} = {\left\lbrack {\iota_{3}^{b}\text{?}1} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack \cdot} \\ {\left\lbrack {_{4}^{b}\text{!}\left( {2*a} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{O_{4}(b)} = {\left\lbrack {\iota_{4}^{b}\text{?}b} \right\rbrack \cdot}} \\ {\left\lbrack {d_{b}\text{!}b} \right\rbrack \cdot} \\ {nil} \end{matrix}$

Suppose now, that the end-user (environment) of this program P(S₁ ) wants to perform the following sequence of actions: runs the program (activates the screen s₁), gives the value 7 to the word a, waits for the value of the word b and then exits the program by pushing the button B₀. This end-user's comportment can be captured by the following process ε: TABLE 14 Process Comments ε = [ι^(ε) ¹ !1].ε₁ Activate the program (screen s₁) ε₁ = [d_(a)!7].ε₂ Give the value 7 to the word a ε₂ = [d_(b)?x].ε₃ Get the value of the word b ε₃ = [d_(B) ₀ !click].nil Click the button B₀ to exit

FIG. 12 shows the process of the program P(S₁) and the end-user's process by the Lyee-calculus described above.

Let's see now how the program P(S₁) interacts with this environment to reach the desired goal. In other words, we trace the program P(S₁) progress when executed in parallel with the program ε that incorporates the end-user actions, i.e., we look for the behaviors of P(s₁)|ε. The steps of this process are as shown hereafter. In the process definition, comments are added with definitions which account for grounds on which the left side of an equation mark is replaced with the right side. A comment is also added to a portion where synchronization (transmission and reception of the value are simultaneously established on the same channel) occurs by the interaction between the processes. An underlined portion shows a synchronized transmission and reception actions. TABLE 15 P(s₁) | ε =

By definition of P and ε

Ψ(s₁)/

(s₁) | [

^(s) ¹ !1].ε₁ =

By definition of Ψ

(([^(s) ¹ ?1]·Φ(s₁))

[

^(s) ⁰ ?1]·nil)/

(s₁) | [^(s) ¹ !1]·ε₁ $\overset{\tau}{->}$

Synchronization - End-user activates the program by running the screen s₁

(Φ(s₁)

[

^(s) ⁰ ?1]·nil)/

(s₁) | ε₁ =

By definition of Φ and ε₁

((SF(s₁)

[

^(s) ¹ ?1]·Φ(s₁))

[

^(s) ⁰ ?1]·nil)/

(s₁) | [d_(a)!7]·ε₂ = (By definition of SF) ((W₀₄(s₁)|W₀₂(s₁)|W₀₃(s₁))

[

^(s) ¹ ?1]·Φ(s₁))

[

^(s) ⁰ ?1]·nil)/

(s₁) | [d_(a)!7]·ε₂ =

By definition of W₀₂ and consequently I₂

${\left( {\left( {\left( {{W_{04}\left( s_{1} \right)}❘{{L_{2}(a)}❘{\left( {\underset{\_}{\left\lbrack {d_{a}\text{?}a} \right\rbrack} \cdot \left\lbrack {\iota_{2}^{a}\text{!}a} \right\rbrack \cdot {nil}} \right)❘{W_{03}\left( s_{1} \right)}}}} \right) \vartriangleright \quad\ldots}\quad \right) \vartriangleright \quad\ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}}❘{{\underset{\_}{\left\lbrack {{d_{a}!}7} \right\rbrack} \cdot ɛ_{2}}\overset{\tau}{->}}$

Synchronization—Through I₂ end-user gives the value 7 to the word a

(((W₀₄(s₁)❘L₂(a)❘([ι₂^(a)!7] ⋅ nil)❘W₀₃(s₁))⊳  …  )⊳  …  )/ℒ(s₁)❘ɛ₂=

By definition of L₂

${\left( {\left( {\left( {{W_{04}\left( s_{1} \right)}❘{\left( {\underset{\_}{\left\lbrack {\iota_{2}^{a}\text{?}a} \right\rbrack} \cdot \left\lbrack {_{4}^{a}\text{!}a} \right\rbrack \cdot {nil}} \right)❘{\left( {\underset{\_}{\left\lbrack {\iota_{2}^{a}\text{!}7} \right\rbrack} \cdot {nil}} \right)❘{W_{03}\left( s_{1} \right)}}}} \right) \vartriangleright \quad\ldots}\quad \right) \vartriangleright \quad\ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}}❘{ɛ_{2}\overset{\tau}{->}}$

Synchronization—The value 7 of a is communicated to L₂(a)

(((W₀₄(s₁)❘([₄^(a)!7] ⋅ nil)❘W₀₃(s₁))⊳  …  )⊳  …  )/ℒ(s₁)❘ɛ₂=

By definition of W₀₄

((S₄(a)❘S₄(b)❘L₄(b, 2 * a)❘O₄(b)❘([₄^(a)!7] ⋅ nil)❘W₀₃(s₁))⊳  …  )/ℒ(s₁)❘ɛ₂=

By definition of S₄(a)

$\left( {{\left( {\left( {\underset{\_}{\left\lbrack {_{4}^{a}\text{?}a} \right\rbrack} \cdot {S_{4}^{a}(a)}} \right)❘{{S_{4}(b)}❘{{L_{4}\left( {b,{2*a}} \right)}❘{{O_{4}(b)}❘{\left( {\underset{\_}{\left\lbrack {_{4}^{a}\text{!}7} \right\rbrack} \cdot {nil}} \right)❘{W_{03}\left( s_{1} \right)}}}}}} \right) \vartriangleright \quad\ldots}\quad\overset{\tau}{->}} \right.$

Synchronization—The value 7 of a is sent from L₂(a) and stored in the memory

((S₄^(a)(7)❘S₄(b)❘L₄(b, 2 * a)❘O₄(b)❘W₀₃(s₁))⊳  …  = ⟨By  definition  of  S₄^(a)(7)  and  W₀₃⟩ ((([₄^(a)?z] ⋅ S₄^(a)(z) + ([ι₄^(a)!7] ⋅ S₄^(a)(7))❘  …  ❘(L₃(b, a > 0)❘R₃(B₀, click, s₀)))⊳  …  =

By definition of L₃

$\left( \left( {\left( {{\left\lbrack {_{4}^{a}\text{?}z} \right\rbrack \cdot {S_{4}^{a}(z)}} + {\underset{\_}{\left\lbrack {\iota_{4}^{a}\text{!}7} \right\rbrack} \cdot {S_{4}^{a}(7)}}} \right)❘\quad{\ldots\quad ❘\left( {\left( {\underset{\_}{\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack} \cdot \left\lbrack {\iota_{3}^{b}\text{!}\left( {a > 0} \right)} \right\rbrack \cdot {nil}} \right)❘\quad{\ldots\quad\overset{\tau}{->}}} \right.}} \right. \right.$

Synchronization—The value of a is communicated to L₃(b) to compute the b condition

((S₄^(a)(7)❘S₄(b)❘L₄(b, 2 * a)❘O₄(b)❘([ι₃^(b)!(7 > 0)] ⋅ nil)❘  …  =

By definition of L₄ and evaluation of (7 > 0)

TABLE 16 $\overset{\tau}{->}$

Synchronization—The b condition is evaluated and communicated to L₄(b) to activate the computation of b

((S₄^(a)(7)❘S₄(b)❘([ι₄^(a)?a] ⋅ [₄^(b)!(2 * a)] ⋅ nil)❘O₄(b)❘  …  = ⟨By  definition  of  S₄^(a)(7)⟩ $\left( \left( {\left( {{\left\lbrack {_{4}^{a}\text{?}z} \right\rbrack \cdot {S_{4}^{a}(z)}} + {\underset{\_}{\left\lbrack {\iota_{4}^{a}\text{!}7} \right\rbrack} \cdot {S_{4}^{a}(7)}}} \right)❘{{S_{4}(b)}❘\left( {{\underset{\_}{\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack} \cdot \left\lbrack {{_{4}^{b}\text{!}\left( {2*a} \right)}❘{\cdot {nil}}} \right)}❘{{O_{4}(b)}❘\quad{\ldots\quad\overset{\tau}{->}}}} \right.}} \right. \right.$

Synchronization—The value of a is communicated to L₄

((S₄^(a)(7)❘S₄(b)❘([₄^(b)!(2 * 7)] ⋅ nil)❘O₄(b)❘R₃(B₀, click, s₀))⊳  …  =

By definition of S₄(b) and evaluation of (2*7)

${\left( {\left( {{S_{4}^{a}(7)}❘{\underset{\_}{\left\lbrack {_{4}^{b}\text{?}b} \right\rbrack} \cdot {S_{4}^{b}(b)}}} \right)❘{\left( {\underset{\_}{\left\lbrack {_{4}^{b}\text{!}(14)} \right\rbrack} \cdot {nil}} \right)❘{{O_{4}(b)}❘{R_{3}\left( {B_{0},{click},s_{0}} \right)}}}} \right) \vartriangleright \quad\ldots}\quad\overset{\tau}{->}$

Synchronization—The value of b(14) is sent from L₄(b) stored in the memory) ((S₄^(a)(7)❘S₄^(b)(14)❘O₄(b)❘R₃(B₀, click, s₀))⊳  …  = ⟨By  the  definition  of  S₄^(b)(14)  and  O₄(b)⟩ $\left( {{\left( {{S_{4}^{a}(7)}❘{\left( {{\left\lbrack {_{4}^{b}\text{?}z} \right\rbrack \cdot {S_{4}^{b}(z)}} + {\underset{\_}{\left\lbrack {\iota_{4}^{b}\text{!}14} \right\rbrack} \cdot {S_{4}^{b}(14)}}} \right)❘{\left( {\underset{\_}{\left\lbrack {\iota_{4}^{b}\text{?}b} \right\rbrack} \cdot \left\lbrack {d_{b}\text{!}b} \right\rbrack \cdot {nil}} \right)❘{R_{3}\left( {B_{0},{click},s_{0}} \right)}}}} \right) \vartriangleright \quad\ldots}\quad\overset{\tau}{->}} \right.$

Synchronization—The value of b(14) is communicated to O₄

((S₄^(a)(7)❘S₄^(b)(14)❘([d_(b)!14] ⋅ nil)❘R₃(B₀, click, s₀))⊳  …  )/ℒ(s₁)❘ɛ₂=

By definition of ε₂

${\left( {\left( {{S_{4}^{a}(7)}❘{{S_{4}^{b}(14)}❘{\left( {\underset{\_}{\left\lbrack {d_{b}\text{!}14} \right\rbrack} \cdot {nil}} \right)❘{R_{3}\left( {B_{0},{click},s_{0}} \right)}}}} \right) \vartriangleright \quad\ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}}❘{{\underset{\_}{\left\lbrack {d_{b}\text{?}x} \right\rbrack} \cdot ɛ_{3}}\overset{\tau}{->}}$

Synchronization—The b value, stored in O₄, is communicated to the environment

((S₄^(a)(7)❘S₄^(b)(14)❘R₃(B₀, click, s₀))⊳  …  )/ℒ(s₁)❘ɛ₃=

By definition of R₃ and ε₃

${\left( {\left( {{S_{4}^{a}(7)}❘{{S_{4}^{b}(14)}❘\left( {\underset{\_}{\left\lbrack {d_{B_{0}}\text{?}{click}} \right\rbrack} \cdot \left\lbrack {\iota^{s_{0}}\text{!}1} \right\rbrack \cdot {nil}} \right)}} \right) \vartriangleright \quad\ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}}❘{{\underset{\_}{\left\lbrack {d_{B_{0}}\text{!}{click}} \right\rbrack} \cdot {nil}}\overset{\tau}{->}}$

Synchronization—The end-user push button B₀ to exit

${\left. {\left( {\left( {{S_{4}^{a}(7)}❘{{S_{4}^{b}(14)}❘\left( {\underset{\_}{\left\lbrack {\iota^{s_{0}}\text{!}1} \right\rbrack} \cdot {nil}} \right)}} \right) \vartriangleright {\left\lbrack {\iota^{s_{1}}\text{?}1} \right\rbrack \cdot {\Phi\left( s_{1} \right)}}} \right) \vartriangleright {\underset{\_}{\left\lbrack {\iota^{s_{0}}\text{?}1} \right\rbrack} \cdot {nil}}} \right)/{\mathcal{L}\left( s_{1} \right)}}\overset{\tau}{->}$

Synchronization—The system ends its execution

nil

To summarize, here are the main steps of the program progress:

The end-user sends a command for activating the program to thereby activate a control function Ψ(s₁). The control function Ψ(s₁) activates a control function Φ(s₁). The control function (s₁) activates an initial screen s₁ and SF (s₁), whereby the program is activated. $\begin{matrix} \left. {\left( {\left( {\underset{\_}{\left\lbrack {\iota^{s_{1}}?1} \right\rbrack} \cdot {\Phi\left( s_{1} \right)}} \right) \vartriangleright {\left\lbrack {\iota^{s_{0}}?1} \right\rbrack \cdot {nil}}} \right)/{\mathcal{L}\left( s_{1} \right)}} \middle| {\underset{\_}{\left\lbrack {{\iota^{s_{1}}!}1} \right\rbrack} \cdot ɛ_{1}} \right. & \left\lbrack {{eq}.\quad 35} \right\rbrack \end{matrix}$

When the end-user gives (transmits) a value “7” to the word a, I₂(a) in SF(s₁) receives the value 7. $\begin{matrix} \left. {\left( {\left( {\left( {W_{04}\left( s_{1} \right)} \middle| {L_{2}(a)} \middle| \left( {\underset{\_}{\left\lbrack {d_{a}?a} \right\rbrack} \cdot \left\lbrack {{\iota_{2}^{a}!}a} \right\rbrack \cdot {nil}} \right) \middle| {W_{03}\left( s_{1} \right)} \right) \vartriangleright \ldots}\quad \right) \vartriangleright \ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}} \middle| {\underset{\_}{\left\lbrack {{d_{a}!}7} \right\rbrack} \cdot ɛ_{2}} \right. & \left\lbrack {{eq}.\quad 36} \right\rbrack \end{matrix}$

The value 7 of the word a is communicated to L₂(a) by I₂(a). $\begin{matrix} \left. {\left( {\left( {\left( {W_{04}\left( s_{1} \right)} \middle| \left( {\underset{\_}{\left\lbrack {\iota_{2}^{a}?a} \right\rbrack} \cdot \left\lbrack {{j_{4}^{a}!}a} \right\rbrack \cdot {nil}} \right) \middle| \left( {\underset{\_}{\left\lbrack {{\iota_{2}^{a}!}7} \right\rbrack} \cdot {nil}} \right) \middle| {W_{03}\left( s_{1} \right)} \right) \vartriangleright \quad\ldots}\quad \right) \vartriangleright \quad\ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}} \middle| ɛ_{2} \right. & \left\lbrack {{eq}.\quad 37} \right\rbrack \end{matrix}$

The value 7 of the word a communicated by L₂(a) is stored in the memory, i.e., S₄ (a) (the initial value is stored in S₄ (a), and the memory is initialized). $\begin{matrix} \left( {\left( \left( {\underset{\_}{\left\lbrack {j_{4}^{a}?a} \right\rbrack} \cdot {S_{4}^{a}(a)}} \right) \middle| \quad{S_{4}(b)} \middle| \quad{L_{4}\left( {b,{2*a}} \right)} \middle| \quad{O_{4}(b)} \middle| \quad\left( {\underset{\_}{\left\lbrack {{j_{4}^{a}!}7} \right\rbrack} \cdot {nil}} \right) \middle| {W_{03}\left( s_{1} \right)} \right) \vartriangleright \ldots} \right. & \left\lbrack {{eq}.\quad 38} \right\rbrack \end{matrix}$

The value 7 of a is communicated from the initialized memory S₄ of a to L₃ (b, a>0) to compute the calculation conditions of b. $\begin{matrix} \left( \left( \left( {{\left\lbrack {j_{4}^{a}?z} \right\rbrack \cdot {S_{4}^{a}(z)}} + {\underset{\_}{\left\lbrack {{\iota_{4}^{a}!}7} \right\rbrack} \cdot {S_{4}^{a}(7)}}} \right) \middle| \quad\ldots \middle| \left( \left( {\underset{\_}{\left\lbrack {\iota_{4}^{a}?a} \right\rbrack} \cdot \left\lbrack {{\iota_{3}^{b}!}\left( {a > 0} \right)} \right\rbrack \cdot {nil}} \right) \middle| \ldots \right. \right. \right. & \left\lbrack {{eq}.\quad 39} \right\rbrack \end{matrix}$

The calculation conditions of b are evaluated (a>0 is judged to be true (1)), and a value of 1 is communicated to L₄(b, 2*a). $\begin{matrix} \left( \left( {S_{4}^{a}(7)} \middle| {S_{4}(b)} \middle| \quad\left( {\underset{\_}{\left\lbrack {\iota_{3}^{b}?1} \right\rbrack} \cdot \left\lbrack {\iota_{4}^{a}?a} \right\rbrack \cdot \left\lbrack {{j_{4}^{b}!}\left( {2*a} \right)} \right\rbrack \cdot {nil}} \right) \middle| {O_{4}(b)} \middle| \left( {\underset{\_}{\left\lbrack {{\iota_{3}^{b}!}1} \right\rbrack} \cdot {nil}} \right) \middle| \ldots \right. \right. & \left\lbrack {{eq}.\quad 40} \right\rbrack \end{matrix}$

The value 7 of a is communicated to L₄(b, 2*a) from the memory S₄ which holds the value 7. $\begin{matrix} \left( \left( \left( {{\left\lbrack {j_{4}^{a}?z} \right\rbrack \cdot {S_{4}^{a}(z)}} + {\underset{\_}{\left\lbrack {{\iota_{4}^{a}!}7} \right\rbrack} \cdot {S_{4}^{a}(7)}}} \right) \middle| \quad{S_{4}(b)} \middle| \left( {\underset{\_}{\left\lbrack {\iota_{4}^{a}?a} \right\rbrack} \cdot \left\lbrack {{j_{4}^{b}!}\left( {2*a} \right)} \right\rbrack \cdot {nil}} \right) \middle| {O_{4}(b)} \middle| \ldots \right. \right. & \left\lbrack {{eq}.\quad 41} \right\rbrack \end{matrix}$

A definition expression “2*a” of b is calculated, and a value 14 of b is stored in the memory, i.e., S₄(b) (S₄(b) is initialized). $\begin{matrix} \left( {\left( {S_{4}^{a}(7)} \middle| \left( {\underset{\_}{\left\lbrack {j_{4}^{b}?b} \right\rbrack} \cdot {S_{4}^{b}(b)}} \right) \middle| \quad\left( {\underset{\_}{\left\lbrack {{j_{4}^{b}!}(14)} \right\rbrack} \cdot {nil}} \right) \middle| \quad{O_{4}(b)} \middle| {R_{3}\left( {B_{0},{click},s_{0}} \right)} \right) \vartriangleright \ldots} \right. & \left\lbrack {{eq}.\quad 42} \right\rbrack \end{matrix}$

The value 14 of b is communicated from the memory S₄ to the output process O₄(b). $\begin{matrix} \left( {\left( {S_{4}^{a}(7)} \middle| \left( {{\left\lbrack {j_{4}^{b}?z} \right\rbrack \cdot {S_{4}^{b}(z)}} + {\underset{\_}{\left\lbrack {{\iota_{4}^{b}!}14} \right\rbrack} \cdot {S_{4}^{b}(14)}}} \right) \middle| \left( {\underset{\_}{\left\lbrack {\iota_{4}^{b}?b} \right\rbrack} \cdot \left\lbrack {{d_{b}!}b} \right\rbrack \cdot {nil}} \right) \middle| {R_{3}\left( {B_{0},{click},s_{0}} \right)} \right) \vartriangleright \ldots} \right. & \left\lbrack {{eq}.\quad 43} \right\rbrack \end{matrix}$

10. The value of b is communicated to the environment by O₄, and the end-user receives the value of b. At this time, processes belonging to SF(s₁) being activated are S₄ which holds values of a and b, and R3 (B₀, click, s₀). $\begin{matrix} \left. {\left( {\left( {S_{4}^{a}(7)} \middle| {S_{4}^{b}(14)} \middle| \left( {\underset{\_}{\left\lbrack {{d_{b}!}14} \right\rbrack} \cdot {nil}} \right) \middle| {R_{3}\left( {B_{0},{click},s_{0}} \right)} \right) \vartriangleright \ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}} \middle| {\underset{\_}{\left\lbrack {d_{b}?x} \right\rbrack} \cdot ɛ_{3}} \right. & \left\lbrack {{eq}.\quad 44} \right\rbrack \end{matrix}$

11. The end-user pushes button B₀ to exit, and R3(B₀, click, s₀) receives the value click, and evaluates its own calculation conditions to transmit a true value of 1 to a control function ψ(S₁). The control function ψ(S₁) which has received the true value of 1 ends Φ(S₁) before the function itself ends, and Φ(S₁) ends SF(S₁) before Φ(S₁) itself ends. $\begin{matrix} \left. {\left( {\left( {S_{4}^{a}(7)} \middle| {S_{4}^{b}(14)} \middle| \left( {\underset{\_}{\left\lbrack {d_{B_{0}}?\quad{click}} \right\rbrack} \cdot \left\lbrack {{\iota^{s_{0}}!}1} \right\rbrack \cdot {nil}} \right) \right) \vartriangleright \ldots}\quad \right)/{\mathcal{L}\left( s_{1} \right)}} \middle| {\underset{\_}{\left\lbrack {{d_{B_{0}}!}\quad{click}} \right\rbrack} \cdot {nil}} \right. & \left\lbrack {{eq}.\quad 45} \right\rbrack \end{matrix}$

FIG. 13 illustrates each of these steps.

The parenthesized numerals correspond to the above description of each step. The numerals that do not have any parentheses indicate values to be transmitted/received.

Furthermore, each transition could be validated by a proof. For instance, there is the transition of the following process (corresponding to the step 1). The synchronization occurs between P(s₁) and ε (transmission and reception of the program activation command), and process transition is represented such that the process shifts to a parallel process of P(s₁) and ε₁. $\begin{matrix} {\left( {{\mathcal{P}\left( s_{1} \right)}❘ɛ} \right)\overset{\tau}{\rightarrow}\left( {{\mathcal{P}_{1}\left( s_{1} \right)}❘ɛ_{1}} \right)} & \left\lbrack {{eq}.\quad 46} \right\rbrack \end{matrix}$ where P(s₁) is as follows. P ₁(s ₁)=(Φ(s ₁)

[

^(s) ⁰ ?1].nil)/

(s ₁)  [eq. 47]

The above is justified by the following proof by use of the rule of Table 5: $\begin{matrix} {R_{|}^{\tau}:\frac{R_{/}:{\frac{R_{\vartriangleright}^{l}:\frac{R_{?}:\frac{1 \in {〚1〛}}{\quad{{\left\lbrack \iota^{s_{1?1}} \right\rbrack \cdot {\Phi\left( s_{1} \right)}}\overset{\iota^{s_{1?1}}}{\rightarrow}\quad{\Phi\left( s_{1} \right)}}}}{\quad{{\Psi\left( s_{1} \right)}\overset{\iota^{s_{1?1}}}{\rightarrow}{{\Phi\left( s_{1} \right)} \vartriangleright {\left\lbrack \iota^{s_{1?1}} \right\rbrack \cdot \quad{nil}}}}\quad}}{\quad{{\mathcal{P}\left( s_{1} \right)}\overset{\iota^{s_{1?1}}}{\rightarrow}\quad{\mathcal{P}_{1}\left( s_{1} \right)}}\quad}{R_{!}:\frac{1 \in {〚1〛}}{ɛ\overset{\iota^{s_{1?1}}}{\rightarrow}ɛ_{1}}}}}{\left( {\mathcal{P}\left( s_{1} \right)} \middle| ɛ \right)\overset{\tau}{\rightarrow}\left( {\mathcal{P}_{1}\left( s_{1} \right)} \middle| ɛ_{1} \right)}} & \left\lbrack {{eq}.\quad 48} \right\rbrack \end{matrix}$

6. CONCLUSION

In this paper, first, we have defined the formal process algebra, called Lyee-calculus, that easily and naturally supports the basic concepts of the Lyee methodology. In fact, this calculus can be seen as an abstract machine which is more suitable to support the Lyee methodology concepts than the Von Newman one. This machine considers a program as a set of molecules that interact together to produce a final result. Secondly, we have shown how this calculus can formalize and simplify both the Lyee vectors together with the whole software generation process. Actually, the routing vectors are no longer needed. Moreover, any pallet function is not unnecessary, and the role of the control function is largely simplified.

We have formalized the whole process of the automatic generation of Lyee software generation. This formalization offers to this methodology a formal semantics that allows one to clearly understand the concepts behind this methodology. Besides, this formal description will be an inevitable start point for many interesting analysis on diverse aspects of this methodology. For instance, to optimize the Lyee generated software or the software generation processes, we need a formal proof that the optimized program is equivalent to its original version. Formal equivalence checking or more generally model checking can be elegantly achieved when using process algebra.

As future work, we want to more investigate the semantics of Lyee methodology in order to make it simpler and to generate, from requirements, more reliable and optimized code. For the optimization end, we intend to define a congruence relation between processes of Lyee-calculus and then using it to prove the correctness of all the eventual optimizations.

EXAMPLE 2

<Appendix>

Case Study 2—Two screens

To show the interaction between many screens, a program constituted of two screens will be described. FIG. 14 is a diagram showing the program screens. When this program is activated, the screen S1 is displayed. In the screen S₁, the user inputs the word a, and waits until the value of the word b is output. When the button B₂ is pushed, the screen S₂ is displayed, and the user waits until the value of the word b is output. When the button B₀ is pushed in the screen S₂, the program ends.

When statements of requirements of the program of FIG. 14 are summarized, the requirement of the screen S₁ is shown in Table 17, and the requirement of the screen S₂ is shown in Table 18. TABLE 17 Word Definition Condition IO . . . a i . . . b 2 * a a > 0 o . . . B₂ S₂ Click i . . .

TABLE 18 Word Definition Condition IO . . . e 1 + b b > 0 o . . . B₀ S₀ Click i . . .

According to the definition of a generic Lyee program given in the previous section, the Lyee program associated to the requirement given by Tables 17 and 18 is as follows: SF(s ₁)=W ₀₄(s ₁)|W ₀₃(s ₁)|W ₀₂(s ₁)  [eq. 49] SF(s ₂)=W ₀₄(s ₁)|W ₀₃(s ₁)

Notice that there is no W₀₂ for the screen s₂ since it does not contain input words other than buttons. $\begin{matrix} {{{\Phi\left( s_{1} \right)} = {{{SF}\left( s_{1} \right)} \vartriangleright {\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}}{{\Phi\left( s_{2} \right)} = {{{SF}\left( s_{2} \right)} \vartriangleright {\left\lbrack {\iota^{s_{2}}?1} \right\rbrack \cdot {\Phi\left( s_{2} \right)}}}}{{\Psi\left( {s_{1},s_{2}} \right)} = {\left( {{\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot {\Phi\left( s_{1} \right)}}❘{\left\lbrack {\iota^{s_{2}}?1} \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright {\left\lbrack {\iota^{s_{0}}?1} \right\rbrack \cdot {nil}}}}{{\mathcal{L}\left( {s_{1},s_{2}} \right)} = \left\{ {d_{a},d_{b},d_{e},d_{B_{0}},d_{B_{2}}} \right\}}{{\mathcal{P}\left( {s_{1},s_{2}} \right)} = {{\Psi\left( {s_{1},s_{2}} \right)}/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}}} & \left\lbrack {{eq}.\quad 50} \right\rbrack \end{matrix}$

wherein W₀₂(s₁), W₀₃(s₁), W₀₄(s₁), W₀₃(s₂), and W₀₄(s₂) are defined as follows. Since the process of R₃ is not essential in the Lyee-calculus in the same manner as in Case Study 1, the process may be omitted. TABLE 19 W₀₂(s₁) = L₂(a) | I₂(a) $\begin{matrix} {{L_{2}(a)} = {\left\lbrack {\iota_{2}^{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{4}^{a}\text{!}a} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{I_{2}(a)} = {\left\lbrack {d_{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{2}^{a}\text{!}a} \right\rbrack \cdot} \\ {nil} \end{matrix}$

TABLE 20 W₀₃(s₁) = L₃(b, a > 0) | R₃(B₂, click, s₂) $\begin{matrix} {{L_{3}\left( {b,{a > 0}} \right)} = {\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{3}^{b}\text{!}\left( {a > 0} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {R_{3}\left( {B_{2},{click},{s_{2} = {\left\lbrack {d_{B_{2}}\text{?}{click}} \right\rbrack \cdot}}} \right.} \\ {\left\lbrack {\iota^{s_{2}}\text{!}1} \right\rbrack \cdot} \\ {nil} \end{matrix}$ W₀₃(s₂) = L₃(e, b > 0) | R₃(B₀, click, s₀) $\begin{matrix} {{L_{3}\left( {e,{b > 0}} \right)} = {\left\lbrack {\iota_{4}^{a}\text{?}b} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{3}^{e}\text{!}\left( {b > 0} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{R_{3}\left( {B_{0},{click},s_{0}} \right)} = {\left\lbrack {d_{B_{0}}\text{?}{click}} \right\rbrack \cdot}} \\ {\left\lbrack {\iota^{s_{0}}\text{!}1} \right\rbrack \cdot} \\ {nil} \end{matrix}$

TABLE 21 W₀₄(s₁) = S₄(a) | S₄(b) | L₄(b, 2*a) | O₄(b) $\begin{matrix} {{S_{4}(a)} = {\left\lbrack {_{4}^{a}\text{?}a} \right\rbrack \cdot}} \\ {S_{4}^{a}(y)} \\ {{S_{4}(b)} = {\left\lbrack {_{4}^{b}\text{?}b} \right\rbrack \cdot}} \\ {S_{4}^{b}(y)} \end{matrix}$ $\begin{matrix} {{L_{4}\left( {b,{2*a}} \right)} = {\left\lbrack {\iota_{3}^{b}\text{!}1} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{4}^{a}\text{?}a} \right\rbrack \cdot} \\ {\left\lbrack {_{4}^{b}\text{!}\left( {2*a} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{O_{4}(b)} = {\left\lbrack {\iota_{4}^{b}\text{?}b} \right\rbrack \cdot}} \\ {\left\lbrack {d_{b}\text{!}b} \right\rbrack \cdot} \\ {nil} \end{matrix}$ W₀₄(s₂) = S₄(e) | L₄(e, 1 + b) | O₄(e) $\begin{matrix} {{S_{4}(e)} = {\left\lbrack {_{4}^{e}\text{?}e} \right\rbrack \cdot}} \\ {S_{4}^{e}(y)} \end{matrix}$ $\begin{matrix} {{L_{4}\left( {e,{1 + b}} \right)} = {\left\lbrack {\iota_{3}^{e}\text{!}1} \right\rbrack \cdot}} \\ {\left\lbrack {\iota_{4}^{b}\text{?}b} \right\rbrack \cdot} \\ {\left\lbrack {_{4}^{e}\text{!}\left( {1 + b} \right)} \right\rbrack \cdot} \\ {nil} \end{matrix}$ $\begin{matrix} {{O_{4}(e)} = {\left\lbrack {\iota_{4}^{e}\text{?}e} \right\rbrack \cdot}} \\ {\left\lbrack {d_{e}\text{!}e} \right\rbrack \cdot} \\ {nil} \end{matrix}$

Suppose now, that the end-user (environment) of this program wants to perform the following sequence of actions to: run the program (activates the screen s₁) ; give the value 7 to the word a; wait until the value of the word b is obtained; push the button B₂ to go to the screen S₂; wait until the value e is obtained; and then exit the program by pushing the button B₀. This comportment can be captured by the following process ε: TABLE 22 End-user Action Comments ε = [l^(ε) ₁!1].ε₁ Activate the program ε₁ = [d_(a)!7].ε₂ Give the value 7 to the word a ε₂ = [d_(b)?b].ε₃ Wait for the value of the word b ε₃ = [l^(B) ₂!click].ε₄ Push the button B₂ to go to the screen 2 ε₄ = [d_(e)?e].ε₅ Wait for the value of the word e ε₅ = [l^(B) ₀!click].nil Push the button B₀ to exit

FIG. 15 shows the process of the program P(S₁) by the Lyee-calculus and the end-user's process described above.

Main steps of the progress of the program are as follows.

The end-user sends a command for activation of the program to thereby activate a control function Ψ(s₁, S₂). The control function Ψ(s₁, s₂) activates a control function Φ(s₁), and the control function Φ(s₁) activates the program by running the screen s₁ and SF(s₁).

Synchronization occurs (program activation command is transmitted/received) between P(s₁, s₂) and ε, and the process shifts to a parallel process of P₁(s₁, S₂) and ε₁. $\begin{matrix} {{\mathcal{P}\left( {s_{1},s_{2}} \right)}❘{{ɛ\overset{\tau}{\rightarrow}{\mathcal{P}_{1}\left( {s_{1},s_{2}} \right)}}❘ɛ_{1}}} & \left\lbrack {{eq}.\quad 51} \right\rbrack \end{matrix}$ where: P ₁(s ₁ ,s ₂)=(Φ(s ₁)|[

^(s) ² ?1].Φ(s ₂)

[

^(s) ⁰ ?1].nil)/

(s ₁ ,s ₂)  [eq. 52]

When the end-user gives (transmits) the value 7 to the word a, I₂(a) in SF(s₁) receives the value 7.

Synchronization occurs (value of the word a is transmitted/received) between P₁(s₁, s₂) and ε₁, and the process shifts to a parallel process of P₂(s₁, s₂) and ε₂. $\begin{matrix} {{\mathcal{P}_{1}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{1}\overset{\tau}{\rightarrow}{\mathcal{P}_{2}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}} & \left\lbrack {{eq}.\quad 53} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{2}\left( {s_{1},s_{2}} \right)} = \left( \left( \left( {\left( {{W_{04}\left( s_{1} \right)}❘{{\left\lbrack {\iota_{2}^{a}{!7}} \right\rbrack \cdot {nil}}❘{{L_{2}(a)}❘{W_{03}\left( s_{1} \right)}}}} \right) \vartriangleright} \right. \right. \right.} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright}} \right. \end{matrix} \\ \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right. \end{matrix} & \left\lbrack {{eq}.\quad 54} \right\rbrack \end{matrix}$

The value 7 of a is stored in the memory S₄(a): This will be done in two steps. First, the value 7 of a is communicated to L₂(a) and second L₂(a) will communicate this value to the memory S4 (a).

The first step is as follows: synchronization occurs in P₂(s₁, s₂) (the value 7 of the word a is transmitted/received between I₂(a) and L₂(a)), and the process shifts to a parallel process of P₃(s₁, s₂) and ε₂. $\begin{matrix} {{\mathcal{P}_{2}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{3}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}} & \left\lbrack {{eq}.\quad 55} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{3}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{W_{04}\left( s_{1} \right)}❘{{\left\lbrack {\iota_{4}^{a}{!7}} \right\rbrack \cdot {nil}}❘{W_{03}\left( s_{1} \right)}}} \right) \vartriangleright} \right. \right.} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright}} \right. \end{matrix} \\ \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right. \end{matrix} & \left\lbrack {{eq}.\quad 56} \right\rbrack \end{matrix}$

In the second, the value 7 of a will be stored in the memory S₄(a) of W₀₄ (the initial value is stored in S₄(a) to thereby initialize the memory). Synchronization occurs in P₃(S₁, S₂) (value 7 of the word a is transmitted/received between L₂(a) and S₄(a)), and the process shifts to a parallel process of P₄(s₁, s₂) and ε₂. $\begin{matrix} {{\mathcal{P}_{3}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{4}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}} & \left\lbrack {{eq}.\quad 57} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{4}\left( {s_{1},s_{2}} \right)} = \left( \left( {{S_{4}^{a}(7)}❘{{S_{4}(b)}❘{L_{4}\left( {b,{2*a}} \right)}}} \right. \right.} \\ {\left. {❘{{O_{4}(b)}❘{W_{03}\left( s_{1} \right)}}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}} \right.} \end{matrix} \\ {❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right.}} \end{matrix} & \left\lbrack {{eq}.\quad 58} \right\rbrack \end{matrix}$

The value 7 of a is communicated from the initialized memory S₄ of a to L₃(b, a>0) to compute the calculation conditions of b. Synchronization occurs in P₄(s₁, s₂) (transmission/reception between S₄(a) and L₃(b, a>0)), and the process shifts to a parallel process of P₅(s₁, s₂) and ε₂. $\begin{matrix} {{\mathcal{P}_{4}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{5}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}} & \left\lbrack {{eq}.\quad 59} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{5}\left( {s_{1},s_{2}} \right)} = \left( \left( \left( {{S_{4}^{a}(7)}❘{{S_{4}(b)}❘{L_{4}\left( {b,{2*a}} \right)}}} \right. \right. \right.} \\ {❘{{O_{4}(b)}❘\left\lbrack {\iota_{3}^{b}{!{\left( {7 > 0} \right) \cdot}}} \right.}} \end{matrix} \\ {\left. {{nil}❘{R_{3}\left( {B_{2},s_{2},{click}}\quad \right)}} \right) \vartriangleright} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘\left\lbrack {\iota^{s_{2}}?1\rbrack\cdot} \right.} \right. \\ {\left. {\Phi\left( s_{2} \right)} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right.} \end{matrix} & \left\lbrack {{eq}.\quad 60} \right\rbrack \end{matrix}$

The calculation conditions of b is evaluated (a>0 is evaluated to be true (1)), and the value 1 is communicated to L₄(b, 2*a). Synchronization occurs in P_(s)(s₁, s₂) (transmission/reception of a true/false value 1 between L₃(b, a>0) and L₄(b, 2*a)), and the process shifts to a parallel process of P₆(s₁, s₂) and ε₂. $\begin{matrix} {{\mathcal{P}_{5}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{6}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}} & \left\lbrack {{eq}.\quad 61} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{6}\left( {s_{1},s_{2}} \right)} = \left( \left( \left( {{S_{4}^{a}(7)}❘{{S_{4}(b)}❘{\left\lbrack {\iota_{4}^{a}{!\left( {2*a} \right)}} \right\rbrack \cdot}}} \right. \right. \right.} \\ {\left. {{nil}❘{{O_{4}(b)}❘{R_{3}\left( {B_{2},s_{2},{click}}\quad \right)}}} \right) \vartriangleright} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘\left\lbrack {\iota^{s_{2}}?1\rbrack\cdot} \right.} \right. \end{matrix} \\ {{\Phi\left( s_{1} \right)}❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?1\rbrack\cdot} \right.}} \\ {\left. {nil} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}} \end{matrix} & \left\lbrack {{eq}.\quad 62} \right\rbrack \end{matrix}$

The value 7 of a is communicated from the memory S₄ of a to L₄(b, 2*a), a definition “2*a” of b is computed, and a value 14 of b is stored in a memory S₄(b) (S₄(b) is initialized). Synchronization occurs in P₆(s₁, s₂) (transmission/reception between the memory S₄ of a and L₄(b, 2*a) and between L₄(b, 2*a) and the memory S4 of b), and the process shifts to a parallel process of P₇(s₁, s₂) and ε₂. ${\mathcal{P}_{6}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{7}\left( {s_{1},s_{2}} \right)}}❘ɛ_{2}}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{7}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{S_{4}^{a}(7)}❘{{S_{4}^{b}(14)}❘{O_{4}(b)}}} \right) \vartriangleright} \right. \right.} \\ {\left. {{\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot {nil}}❘{R_{3}\left( {B_{2},s_{2},{click}}\quad \right)}} \right) \vartriangleright} \end{matrix} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright}} \right. \\ \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right. \end{matrix} & \left\lbrack {{eq}.\quad 64} \right\rbrack \end{matrix}$

The value 14 of b is communicated from the memory S₄ of b to an output process O₄(b). The b value is communicated to the environment by O₄(b), and the end user receives the value of b. Synchronization occurs in P₇(s₁, s₂) (transmission/reception between L₄(b, 2*a) and O₄(b)), synchronization occurs between P₇(s₁, s₂) and ε₂ (transmission/reception of value of word b), and the process shifts to P₈(s₁, s₂) and ε₃.

At this time, processes belonging to SF(s₁) being activated are S₄ which holds values of a and b, and R3(B₀, click, s₀). $\begin{matrix} {{\mathcal{P}_{7}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{2}\overset{\tau}{\rightarrow}{\mathcal{P}_{8}\left( {s_{1},s_{2}} \right)}}❘ɛ_{3}}} & \left\lbrack {{eq}.\quad 65} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{8}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{S_{4}^{a}(7)}❘{{S_{4}^{b}(14)}❘{R_{3}\left( {B_{2},s_{2},{click}}\quad \right)}}} \right) \vartriangleright} \right. \right.} \\ \left\lbrack {{\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}}❘{\left\lbrack {\iota^{s_{2}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{2} \right)}}} \right) \vartriangleright}} \right. \end{matrix} \\ \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right. \end{matrix} & \left\lbrack {{eq}.\quad 66} \right\rbrack \end{matrix}$

The end-user pushes the button B₂ in the screen s₁ to go to screen s₂. R3(B₂, click, s₂) receives the button-B₂-clicked value transmitted from ε₃, and R3(B₂, click, s₂) evaluates its own calculation conditions to transmit a true value of 1 to a control function Ψ(s₁, s₂). The control function Ψ(s₁, s₂) which has received the value 1 activates the control function Φ(s₂). The control function Φ(s₂) which has received the value 1 activates SF(s₂) and the screen s₂. There occur: synchronization between P₈(s₁, s₂) and ε₃ (transmission/reception of the value clicked by the button B₂); and synchronization in P₈(s₁, s2) (transmission/reception between R3(B₂, click, s₂) and Ψ(s₁, s₂) and the control function Φ(s₂)), and the process shifts to a parallel process of P₉(s₁, s₂) and ε₄. $\begin{matrix} {{\mathcal{P}_{8}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{3}\overset{\tau}{\rightarrow}{\mathcal{P}_{9}\left( {s_{1},s_{2}} \right)}}❘ɛ_{4}}} & \left\lbrack {{eq}.\quad 67} \right\rbrack \end{matrix}$ where: P ₉(s ₁ ,s ₂)=(((S ₄ ^(a)(7)|S ₄ ^(b)(14))

[

^(s) ¹ ?1].Φ(s ₁)|Φ(s ₂))

[

^(s) ⁰ 1?1].nil)/

(s ₁ ,s ₂)  [eq. 68]

To compute the condition of e, the memory S₄ of b transmits value 14 to L₃(e, b>0). Synchronization occurs in P₉(s₁, s₂) (transmission/reception between the memory S₄ of a and L₃(e, b>0)), and the process shifts to a parallel process of P₁₀(s₁, s₂) and ε₄. $\begin{matrix} {{\mathcal{P}_{9}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{4}\overset{\tau}{\rightarrow}{\mathcal{P}_{10}\left( {s_{1},s_{2}} \right)}}❘ɛ_{4}}} & \left\lbrack {{eq}.\quad 69} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{10}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{S_{4}^{a}(7)}❘{S_{4}^{b}(14)}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?1\rbrack\cdot} \right.} \right. \right.} \\ {{\Phi\left( s_{1} \right)}❘\left( {{W_{04}\left( s_{2} \right)}❘{\left\lbrack {\iota_{3}^{e}\left( {14 > 0} \right)} \right\rbrack \cdot}} \right.} \end{matrix} \\ {\left. {{nil}❘{R_{3}\left( {B_{0},s_{0},{click}}\quad \right)}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?1\rbrack\cdot} \right.} \end{matrix} \\ {\left. {\Phi\left( s_{1} \right)} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right.} \end{matrix} & \left\lbrack {{eq}.\quad 70} \right\rbrack \end{matrix}$

The calculation condition b>0 of e is evaluated to be true (1), a true value 1 is transmitted from L₃(e, b>0) to L₄(e, 1+b), and the value of e is computed. Synchronization occurs in P₁₀(s₁, s₂) (transmission/reception between L₃(e, b>0) and L₄(e, 1+b), and the process shifts to a parallel process of P₁₁(s₁, s₂) and ε₄. $\begin{matrix} {{\mathcal{P}_{10}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{4}\overset{\tau}{\rightarrow}{\mathcal{P}_{11}\left( {s_{1},s_{2}} \right)}}❘ɛ_{4}}} & \left\lbrack {{eq}.\quad 71} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{11}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{S_{4}^{a}(7)}❘{S_{4}^{b}(14)}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?1\rbrack\cdot} \right.} \right. \right.} \\ {{\Phi\left( s_{1} \right)}❘\left( {{S_{4}(e)}❘{\left\lbrack {\gimel_{4}^{e}\left( {1 + 14} \right)} \right\rbrack \cdot}} \right.} \end{matrix} \\ {\left. {{nil}❘{{O_{4}(e)}❘{R_{3}\left( {B_{0},s_{0},{click}}\quad \right)}}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?1\rbrack\cdot} \right.} \end{matrix} \\ {\left. {\Phi\left( s_{1} \right)} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right.} \end{matrix} & \left\lbrack {{eq}.\quad 72} \right\rbrack \end{matrix}$

Store the value of e from L₄(e, 1+b) in the memory S₄(b) of e (S₄(b) is initialized). Synchronization in P₁₁(s₁, s₂) (transmission/reception between L₄(e) and the memory S₄ of e) and the process shifts to a parallel process of P₁₂(s₁, s₂) and ε₄. $\begin{matrix} {{\mathcal{P}_{11}\left( {s_{1},s_{2}} \right)}❘{{ɛ_{4}\overset{\tau}{\rightarrow}{\mathcal{P}_{12}\left( {s_{1},s_{2}} \right)}}❘ɛ_{4}}} & \left\lbrack {{eq}.\quad 73} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} \begin{matrix} {{\mathcal{P}_{12}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {{S_{4}^{a}(7)}❘{S_{4}^{b}(14)}} \right) \vartriangleright \left\lbrack {\iota^{s_{1}}?1\rbrack\cdot} \right.} \right. \right.} \\ {{\Phi\left( s_{1} \right)}❘{\left( {{S_{4}^{e}(15)}❘{{O_{4}(e)}❘{R_{3}\left( {B_{0},s_{0},{click}}\quad \right)}}} \right) \vartriangleright}} \end{matrix} \\ {\left\lbrack {\iota^{s_{1}}?{\left. 1 \right\rbrack \cdot {\Phi\left( s_{1} \right)}}} \right) \vartriangleright \left\lbrack {\iota^{s_{0}}?{\left. {\left. 1 \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \right.} \end{matrix} & \left\lbrack {{eq}.\quad 74} \right\rbrack \end{matrix}$

Transmit a value 15 of e from the memory S₄(b) of e to O₄(e), and output the value of e from O₄(e) to the end-user ε₄. Synchronization occurs between P₁₁(s₁, s₂) and ε₄ (transmission/reception of the value 14 of the word e), and the process shifts to a parallel process of P12(s₁, s₂) and ε₅. $\begin{matrix} {{\mathcal{P}_{11}\left( {s_{1},s_{2}} \right)}{{ɛ_{4}\overset{\tau}{\rightarrow}{\mathcal{P}_{12}\left( {s_{1},s_{2}} \right)}}}ɛ_{5}} & \left\lbrack {{eq}.\quad 75} \right\rbrack \end{matrix}$ where: $\begin{matrix} \begin{matrix} {{\mathcal{P}_{12}\left( {s_{1},s_{2}} \right)} = \left( \left( {\left( {S_{4}^{a}(7)} \middle| {S_{4}^{b}(14)} \right) \vartriangleright {\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot}} \right. \right.} \\ {{\Phi\left( s_{1} \right)\left. {\left( {S_{4}^{e}(15)} \right.{R_{3}\left( {B_{0},s_{0},{click}} \right)}} \right)} \vartriangleright {\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot}} \\ {\left. {\Phi\left( s_{1} \right)} \right) \vartriangleright {\left\lbrack {\left. \quad{\iota^{s_{0}}?1} \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}} \end{matrix} & \left\lbrack {{eq}.\quad 76} \right\rbrack \end{matrix}$

The end-user pushes B₀ to exit the program, and R3(B₀, click, s₀) receives the value click of the button B₀ from the end-user ε₅, and transmit the value to a control function ψ(s₁, s₂). The control function ψ(s₁, s₂) ends Φ(s₁) and Φ(s₂) before the function itself ends, and Φ(s₁) ends SF(s₁) and Φ(s₂) ends SF(s₂), respectively, before they end. Synchronization occurs between P₁₂(s₁, s₂) and ε₅ (transmission/reception of Click value), next synchronization occurs in P₁₂(s₁, s₂) (transmission/reception of R3(B₀, click, s₀), Ψ(s₁, s₂), and the control functions Φ(s₁) and Φ(s₂)), and all the processes shift to nil. $\begin{matrix} \begin{matrix} \begin{matrix} \left. {\mathcal{P}_{12}\left( {s_{1},s_{2}} \right)} \middle| {ɛ_{5}\overset{\tau}{\rightarrow}\left( \left( {\left( {S_{4}^{a}(7)} \middle| {S_{4}^{b}(14)} \right) \vartriangleright {\left\lbrack {\iota^{s_{1}}?1} \right\rbrack \cdot}} \right. \right.} \right. \\ {\left. {{\Phi\left( s_{1} \right)\left. {{\left( {S_{4}^{e}(15)} \right.\left\lbrack {\iota^{s_{0}}?1} \right\rbrack} \cdot {nil}} \right)} \vartriangleright \left\lbrack {\quad{\iota^{s_{1}}?1}} \right.} \right\rbrack \cdot} \end{matrix} \\ {{\left. {\Phi\left( s_{1} \right)} \right) \vartriangleright {\left\lbrack {\left. \quad{\iota^{s_{0}}?1} \right\rbrack \cdot {nil}} \right)/{\mathcal{L}\left( {s_{1},s_{2}} \right)}}}\overset{\tau}{\rightarrow}{nil}} \end{matrix} & \left\lbrack {{eq}.\quad 77} \right\rbrack \end{matrix}$

It is to be noted that the present invention is not limited to the above-described embodiments and examples, and various modifications are possible in a region of technical idea of the present invention. The present invention can be realized as, for example, a business method, a software development device, a software development support device, a software development and management device, software for realizing these functions in a computer, a recording medium or an special purpose machine on which the software is installed or the like. Furthermore, needless to say, as described above, the present invention can be realized as a method, software having such function, a device or a tool (including the software itself) on which the software is installed, or a system.

For example, FIG. 16 is a functional block diagram showing, as one of different embodiments of the present invention, a constitution including a function in a case where the present invention is embodied as one of a program (software) for producing “software of a development object”, a program generation device, a program processing device, a tool (including both of tools as a device and software), a software development device, a software development support device, and a software development and management device. As shown in the drawing, the present invention is one of the program (software), the program generating device, the program processing device, the tool (including both of the tools as the device and the software), the software development device, the software development support device, and the software development and management device. The present invention includes an overall control section 1601, a statement information assignment section 1602, a control function Φ placement section 1603, a control function Ψ placement section 1604, and an information memory section 1605.

The overall control section 1601 has a function of performing the whole operation control, timing control, input/output control and the like of the present program (software), the program generating device, the program processing device, the tool (including both of the tools as the device and the software), the software development device, the software development support device, and the software development and management device. The overall control section is realized as an special purpose chip having the function, an special purpose circuit, software (also including the software as the tool) for allowing the computer to perform the function, a recording medium in which the software is recorded, or a processing device, a management device, or a tool on which the recording medium is mounted.

The statement information assignment section 1602 has a function of assigning information into undefined parts of models of signification vectors (L₂, L₃, L₄) and action vectors (I₂, O₄, S₄), each of which is a module of a process cell having input/output channels based on the Lyee-calculus, and such assigned information is formed from a user requirement to be implemented as one program into statements, and each of such statements declared by word and grouped by logical record includes a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word. The section is realized as a special purpose chip or a special purpose circuit having the function, software (including software as a tool) for allowing a computer to perform the function, a recording medium in which the software is recorded, or a processing device, a management device or a tool on which the recording medium is mounted.

The control function Φ placement section 1603 has a function of associating control function modules Φ so that a single control function module Φ controls a single set of the signification vectors and the action vectors which are grouped on the set condition that interactions among it are caused by a command from the same screen. The section is realized as a special purpose chip or a special purpose circuit having the function, software (including software as a tool) for allowing a computer to perform the function, a recording medium in which the software is recorded, or a processing device, a management device or a tool on which the recording medium is mounted.

The control function Ψ placement section 1604 has a function of associating a control function module Ψ so that a sigle control function Ψ controls the control function modules Φ. The section is realized as a special purpose chip or a special purpose circuit having the function, software (including software as a tool) for allowing a computer to perform the function, a recording medium in which the software is recorded, or a processing device, a management device or a tool on which the recording medium is mounted.

The information memory section 1605 is used as a storage of: program information; further various control information; the models of the signification vectors (L2, L3, L4) and the action vectors (I2, O4, S4), each of which is formed as a module of a process cell; the model of the control function module Φ; the model of the control function module Ψ; a target program and the like. Moreover, the section is also used as a memory for temporary storage.

FIG. 17 is a flowchart showing an operation of the present invention implemented as one the followings which has the above-described constitution: program (software) a program generating device, a program processing device, a tool (including both of tools as the device and the software), a software development device, a software development support device, and a software development and management device.

As shown in the drawing, first the statement information assignment section 1602 inserts the information into the undefined parts of the models of the signification vectors (L2, L3, L4) and the action vectors (I2, O₄, S4), each of which is formed as the module of the process cell having the input/output channels based on the Lyee-calculus; such information is formed from the user requirement to be implemented as one program into the statements; each of such statements declared by word and grouped by logical record includes a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word (step 1701).

Then, the control function Φ placement section 1603 associates control function modules Φ so that a single control function module Φ controls a single set of the signification vectors and the action vectors which are grouped on the set conditions that interactions among it are caused by the command from the same screen (step 1702).

Next, the control function Ψ placement section 1604 associates one control function module Ψ so that a single control function Ψ controls the control function modules Φ (step 1703).

Therefore, according to the present invention constituted as described above, the requirement is defined on the basis of the theoretical system unique to the present invention, and the defined requirement is assigned into the undefined parts of the models of the signification vectors (L2, L3, L4) and the action vectors (I2, O4, S4), each of which is the module of the process cell having the structure unique to the present invention. Therefore, desired software can be obtained without humane/personal elements.

A program (software) for producing “software of a development object”, a program generation device, a program processing device, a tool (including the tools as both the device and the software), a software development device, a software development support device, or a software development and management device as one of different embodying units of the present invention may include: statement information assignment means for assigning information into undefined parts of the models of the signification vectors (L₂, L₃, L₄) and the action vectors (I₂, O₄, S₄), each of which is formed into the module of a process cell having input/output channels based on the Lyee-calculus, where the information is formed from a user requirement to be mounted as one program into statements, and each of such statements declared by word and grouped by logical record includes a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word; control function Φ placement means for associating control function modules Φ so that a single control function module Φ controls a single set of the signification vectors and the action vectors grouped on the set condition that interactions among it are caused by a command from the same screen; and control function Ψ placement means for associating one control function module Ψ so as to control the control function modules Φ.

The present invention is also realized by the software produced by the above-described “method of producing software of the development object”, a recording medium on which the software is mounted, or a device (hardware) on which the software is mounted. In this case, the present invention may be constituted of: modules made from the models of the signification vectors (L₂, L₃, L₄) and the action vectors (I₂, O₄, S₄), each of which is the module of a process cell having input/output channels based the Lyee-calculus, and such modules are made by assigning information to undefined parts of such models, and such information is formed from a user requirement to be implemented as one program into statements, and each of such statements declared by word and grouped by logical record has a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word; control function modules Φ associated so that a single control function module Φ controls a set of the above mentioned modules grouped based on the set condition that interactions among it are caused by a command from the same screen; and a control function module Ψ associated so that a single control function module Ψ controls the control funcion modules Φ.

Furthermore, the present invention is also realized as software which is a model of a software code for use in producing software by the above-described “method of producing the software of the development object”, a recording medium on which the software is mounted, or a device (hardware) on which the software is mounted. In this case, the present invention may be constituted of: models of the signification vectors (L₂, L₃, L₄) and the action vectors (I₂, O₄, S₄),each of which is the module of a process cell having input/output channels based the Lyee-calculus, and such modules have undefined parts where information should be assigned, and such information is formed from a user requirement to be implemented as one program into statements, where each of such statements declared by word and grouped by logical record has a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the; a model of control function module Φ which has a function that a single control function module Φ controls a set of the signification vectors and the action vectors which have the statement information in the unidentified parts, and such set is grouped based on the set condition that interactions among it are caused by a command from the same screen; and a model of control function module Ψ which has a function that a single control function module Ψ controls the control function modeuls Φ.

Furthermore, the present invention can be realized by the above-described “method of producing the software of the development object” as any of a method of extracting information (document (paper, data)) extracted from a requirement, the information (document (paper, data)) extracted by such extraction method, a method of using the extracted information, an information recording medium on which these information is mounted, software in which an information extracting/using method is coded, and a recording medium/device (hardware) on which the software is mounted. In this case, the present invention may be realized as information extracted from a software development requirement, including: information formed from a user requirement to be mounted as one program into statements, each of which is declared by word and grouped by logical record and has a word name, a definition expression, a condition for executing the definition expression, an input/output attribute, and an attribute of a value of the word, and such information being to be assigned into undefined parts of the models of the signification vectors (L₂, L₃, L₄) and the action vectors (I₂, O₄, S₄), each of which is the module of a process cell having input/output channels based on the Lyee-calculus; information for associating control function modules Φ so that a single control function module Φ controls a single set of the signification vectors and the action vectors, which have the above mentioned information in their unidentified parts, and such set is grouped on the set condition that interactions among it are caused by a command from the same screen; and information for associating a control function module Ψ so as to control the control function modules Φ.

Furthermore, the present invention permits various modifications, additions, replacements, enlargements, reductions and the like in identical and equivalent regions of the technical idea. The value of the present invention is not lowered at all even in a case where the device, the method, the software, or the system produced using the present invention is mounted on a secondary product, and commercialized.

INDUSTRIAL APPLICABILITY

A wide range of software problems related to different fields are efficiently dealt with, and development time, maintenance time and documentation volume can be considerably reduced by using Lyee (as much as 70 to 80%) as compared with conventional methodologies.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a schematic diagram showing a concept of Cell in one embodiment of the present invention;

FIG. 2 is a diagram showing Example of Interacting Processes in one embodiment of the present invention;

FIG. 3 is a schematic diagram showing a concept of requirement execution in one embodiment of the present invention;

FIG. 4 is a schematic diagram showing a concept of Lyee Pallets in one embodiment of the present invention;

FIG. 5 is a schematic diagram showing a concept of Basic Structure (Scenario Function) in one embodiment of the present invention;

FIG. 6 is a schematic diagram showing a concept of Predicate Vector in one embodiment of the present invention;

FIG. 7 is a schematic diagram showing concepts of the Predicate Vectors of L4_a and L4_b in one embodiment of the present invention;

FIG. 8 is a schematic diagram showing concepts of the Predicate Vectors of L3_a and L3_b in one embodiment of the present invention;

FIG. 9 is a schematic diagram showing a concept of Screen Interaction in one embodiment of the present invention;

FIG. 10 is a schematic diagram showing Processes Route Diagram in one embodiment of the present invention;

FIG. 11 is a schematic diagram showing Case Study—One Screen in one embodiment of the present invention (Embodiment 1);

FIG. 12 is an explanatory view showing a process of program P(S₁) and end-user's process by the Lyee-calculus in one embodiment of the present invention;

FIG. 13 is a schematic diagram showing Interaction between processes in one embodiment of the present invention;

FIG. 14 is a schematic diagram showing Case Study—Two Screens in one embodiment of the present invention (Embodiment 2);

FIG. 15 is an explanatory view showing a process of program P(S₁) and end-user's process by the Lyee-calculus in one embodiment of the present invention;

FIG. 16 is a functional block diagram showing a constitution of functional units in one of different embodiments of the present invention in a case where the present invention is embodied as one of a program (software) for producing “software of a development object”, a program gemeration device, a program processing device, a tool (including both of tools as the device and the software), a software development device, a software development support device, and a software development and management device; and

FIG. 17 is a flowchart showing an operation of the persent invention embodied as one of the program (software), the program generation device, the program processing device, the tool (including both of tools as the device and the software), the software development device, the software development support device, and the software development and management device constituted as described above in one embodiment of the present invention.

DESCRIPTION OF SYMBOLS

-   W04 W04 pallet -   W02 W02 pallet -   W03 W03 pallet -   1601 overall control section -   1602 statement information assignment section -   1603 control function Φ placement section -   1604 control function Ψ placement section -   1605 information memory section 

1. A software generation method comprising: a first step for making a statement (defining) a user requirement to be mounted as one program by a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; a second step for preparing, from said statement of the word unit, a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus; a third step for assembling said signification vector and said action vector into a set having set conditions that an interaction is caused by a command from an identical screen; a fourth step for disposing one control function module Φ for every set; and a fifth step for disposing a control function module Ψ being one for every said program.
 2. A software generation method comprising: determining a statement (defining) a user requirement to be mounted as one program by a word name, a definition equation, conditions for executing the definition equation, input/output attributes, and an attribute of a value of a word for every logical unit and for every word of the logical unit; determining, from said statement of the word unit, a signification vector (L₂, L₃, L₄) and an action vector (I₂, O₄, S₄) formed into a module as a process cell comprising an input/output channel by Lyee-calculus; assembling said signification vector and said action vector into a set having set conditions that an interaction is caused by a command from an identical screen; disposing one control function module Φ for every set; and disposing a control function module Ψ being one for every said program. 